मैं एक C प्रोग्रामर हूं, जो C ++ को समझने की कोशिश कर रहा है। कई ट्यूटोरियल स्निपेट का उपयोग करके ऑब्जेक्ट इंस्टेंटेशन को प्रदर्शित करते हैं जैसे:
Dog* sparky = new Dog();जिसका अर्थ है कि बाद में आप क्या करेंगे:
delete sparky;जो समझ में आता है। अब, मामले में जब गतिशील मेमोरी आवंटन अनावश्यक है, तो क्या इसके बजाय उपरोक्त उपयोग करने का कोई कारण है
Dog sparky;और एक बार स्पार्कली स्कोप के दायरे से बाहर जाने पर विध्वंसक कहलाता है?
धन्यवाद!
जवाबों:
इसके विपरीत, आपको हमेशा स्टैक आवंटन पसंद करना चाहिए, इस हद तक कि अंगूठे के नियम के रूप में, आपको अपने उपयोगकर्ता कोड में नया / हटाना कभी नहीं चाहिए।
जैसा कि आप कहते हैं, जब वेरिएबल को स्टैक पर घोषित किया जाता है, तो इसका विध्वंसक स्वचालित रूप से कहा जाता है जब यह कार्यक्षेत्र से बाहर चला जाता है, जो संसाधन जीवनकाल पर नज़र रखने और लीक से बचने के लिए आपका मुख्य उपकरण है।
तो सामान्य तौर पर, हर बार आपको एक संसाधन आवंटित करने की आवश्यकता होती है, चाहे वह मेमोरी हो (नए कॉल करके), फ़ाइल हैंडल, सॉकेट या कुछ और, इसे उस वर्ग में लपेटें जहां निर्माता संसाधन का अधिग्रहण करता है, और विध्वंसक इसे जारी करता है। तब आप स्टैक पर उस प्रकार का ऑब्जेक्ट बना सकते हैं, और आप गारंटी देते हैं कि जब यह कार्यक्षेत्र से बाहर हो जाता है तो आपका संसाधन मुक्त हो जाता है। इस तरह से आपको मेमोरी लीक से बचने के लिए हर जगह अपने नए / डिलीट पेयर को ट्रैक करने की आवश्यकता नहीं है।
इस मुहावरे का सबसे आम नाम RAII है
इसके अलावा स्मार्ट पॉइंटर क्लासेस देखें जो दुर्लभ मामलों में परिणामी बिंदुओं को लपेटने के लिए उपयोग किए जाते हैं जब आपको एक समर्पित RAII ऑब्जेक्ट के बाहर नए के साथ कुछ आवंटित करना होता है। आप इसके बजाय पॉइंटर को एक स्मार्ट पॉइंटर को पास करते हैं, जो तब अपने जीवनकाल को ट्रैक करता है, उदाहरण के लिए रेफरेंस काउंटिंग द्वारा, और डिस्ट्रक्टर को कॉल करता है जब आखिरी रेफरेंस निकलता है। मानक पुस्तकालय हैstd::unique_ptr सरल गुंजाइश-आधारित प्रबंधन है, और std::shared_ptrजो साझा स्वामित्व को लागू करने के लिए संदर्भ गिनती करता है।
कई ट्यूटोरियल ऐसे स्निपेट का उपयोग करके ऑब्जेक्ट इंस्टेंशन को प्रदर्शित करते हैं जैसे ...
तो आपने जो खोजा है, वह है कि अधिकांश ट्यूटोरियल चूसें। ;) अधिकांश ट्यूटोरियल आपको घटिया सी ++ अभ्यास सिखाते हैं, जिसमें आवश्यक नहीं होने पर वैरिएबल बनाने के लिए नए / हटाने को कॉल करना और आपको अपने आवंटन के जीवनकाल पर नज़र रखने के लिए कठिन समय देना शामिल है।
यद्यपि स्टैक पर चीजें होने से आवंटन और स्वत: मुक्त होने के संदर्भ में एक फायदा हो सकता है, लेकिन इसके कुछ नुकसान हैं।
आप ढेर पर भारी वस्तुओं को आवंटित नहीं करना चाह सकते हैं।
गतिशील प्रेषण! इस कोड पर विचार करें:
#include <iostream>
class A {
public:
virtual void f();
virtual ~A() {}
};
class B : public A {
public:
virtual void f();
};
void A::f() {cout << "A";}
void B::f() {cout << "B";}
int main(void) {
A *a = new B();
a->f();
delete a;
return 0;
}यह "बी" प्रिंट करेगा। अब देखते हैं कि स्टैक का उपयोग करते समय क्या होता है:
int main(void) {
A a = B();
a.f();
return 0;
}यह "ए" प्रिंट करेगा, जो उन लोगों के लिए सहज नहीं हो सकता है जो जावा या अन्य वस्तु उन्मुख भाषाओं से परिचित हैं। कारण यह है कि आपके पास Bअब किसी भी उदाहरण के लिए सूचक नहीं है। इसके बजाय, का एक उदाहरण Bबनाया और aप्रकार के चर के लिए नकल की हैA ।
कुछ चीजें अनजाने में हो सकती हैं, खासकर जब आप C ++ में नए हों। C में आपके पास अपने पॉइंटर्स हैं और यही है। आप जानते हैं कि उनका उपयोग कैसे करना है और वे हमेशा ऐसा ही करते हैं। C ++ में ऐसा नहीं है। जरा कल्पना करें कि क्या होता है, जब आप इस उदाहरण में एक विधि के लिए एक तर्क के रूप में उपयोग करते हैं - चीजें अधिक जटिल हो जाती हैं और यह बहुत बड़ा अंतर बनाता है यदि aप्रकार Aया A*या A&(कॉल-बाय-संदर्भ) है। कई संयोजन संभव हैं और वे सभी अलग-अलग व्यवहार करते हैं।
ठीक है, पॉइंटर का उपयोग करने का कारण बिल्कुल वैसा ही होगा कि सी में पॉइंटर्स का उपयोग मॉलॉक के साथ आवंटित करने का कारण: यदि आप चाहते हैं कि आपकी वस्तु आपके चर से अधिक समय तक जीवित रहे!
यदि आप इससे बच सकते हैं, तो नए ऑपरेटर का उपयोग नहीं करने की भी अत्यधिक अनुशंसा की जाती है। खासकर यदि आप अपवादों का उपयोग करते हैं। सामान्य तौर पर यह संकलक को अपनी वस्तुओं को मुक्त करने के लिए अधिक सुरक्षित होता है।
मैंने इस प्रतिमान को उन लोगों से देखा है, जिन्हें ऑपरेटर का पता और पता नहीं मिलता है। यदि उन्हें एक पॉइंटर के साथ फ़ंक्शन को कॉल करने की आवश्यकता होती है, तो वे हमेशा हीप पर आवंटित करेंगे ताकि उन्हें एक पॉइंटर मिले।
void FeedTheDog(Dog* hungryDog);
Dog* badDog = new Dog;
FeedTheDog(badDog);
delete badDog;
Dog goodDog;
FeedTheDog(&goodDog);हीप को एक बहुत ही महत्वपूर्ण अचल संपत्ति के रूप में मानते हैं और इसका उपयोग बहुत ही विवेकपूर्ण तरीके से करते हैं। जब भी संभव हो स्टैक का उपयोग करना मूल अंगूठे का नियम है और जब भी कोई अन्य तरीका न हो तो हीप का उपयोग करें। स्टैक पर ऑब्जेक्ट्स को आवंटित करके आप कई लाभ प्राप्त कर सकते हैं जैसे:
(1)। आपको अपवादों के मामले में स्टैक अनइंडिंग के बारे में चिंता करने की आवश्यकता नहीं है
(2)। आपको अपने ढेर प्रबंधक द्वारा आवश्यक से अधिक स्थान आवंटित करने के कारण स्मृति विखंडन के बारे में चिंता करने की आवश्यकता नहीं है।
एकमात्र कारण यह है कि डॉग को ढेर के बजाय अब स्टैक पर आवंटित किया गया है। इसलिए अगर डॉग आकार में मेगाबाइट है, तो आपको समस्या हो सकती है,
यदि आपको नया / हटाए जाने वाले मार्ग पर जाने की आवश्यकता है, तो अपवादों से सावधान रहें। और इस वजह से आपको ऑब्जेक्ट जीवनकाल को प्रबंधित करने के लिए auto_ptr या बूस्ट स्मार्ट पॉइंटर प्रकारों में से एक का उपयोग करना चाहिए।
नए (ढेर पर) का कोई कारण नहीं है जब आप स्टैक पर आवंटित कर सकते हैं (जब तक कि किसी कारण से आपको एक छोटा स्टैक नहीं मिला है और ढेर का उपयोग करना चाहते हैं।
यदि आप ढेर पर आवंटित करना चाहते हैं, तो आप मानक पुस्तकालय से एक साझा_पट्र (या इसके किसी एक संस्करण) का उपयोग करने पर विचार कर सकते हैं। एक बार जब आप सभी के लिए डिलीट को हैंडल कर लेंगे तो share_ptr के सभी संदर्भ अस्तित्व से बाहर हो जाएंगे।
एक अतिरिक्त कारण है, जिसका किसी और ने उल्लेख नहीं किया है, आप अपनी वस्तु को गतिशील बनाने के लिए क्यों चुन सकते हैं। गतिशील, हीप आधारित वस्तुएं आपको बहुरूपता का उपयोग करने की अनुमति देती हैं ।
विजुअल स्टूडियो में भी मुझे यही समस्या थी। आपको उपयोग करना होगा:
yourClass-> classMethod ();
बजाय:
yourClass.classMethod ();