क्या myVector.erase (myPtr) myPtr द्वारा इंगित ऑब्जेक्ट को हटाता है?

Question

अगर मैं निम्नलिखित कोड है,

Foo *f = new Foo(); 
vector<Foo*> vect; 
vect.push_back(f); 
// do stuff 
vect.erase(f); 

मैं एक स्मृति रिसाव में बनाया है? मुझे ऐसा लगता है, लेकिन शब्द मिटा देता है यह महसूस करता है कि यह इसे हटा रहा है।

यह लिखकर, मुझे आश्चर्य है कि एसटीएल वेक्टर में पॉइंटर डालने की कोई गलती नहीं है। तुम क्या सोचते हो?

Answer 1

हां, आपने उसमें एक स्मृति रिसाव बनाया है। std :: वेक्टर और अन्य कंटेनर सिर्फ पॉइंटर को हटा देंगे, वे सूचक पॉइंटर पॉइंट को मुक्त नहीं करेंगे।

मानक पुस्तकालय कंटेनर में पॉइंटर डालना असामान्य नहीं है। हालांकि, समस्या यह है कि कंटेनर से इसे हटाते समय आपको इसे हटाने का ट्रैक रखना होगा।

{ 
    boost::shared_ptr<foo> f(new foo); 

    std::vector< boost::shared_ptr<foo> > v; 
    v.push_back(f); 
    v.erase(v.begin()); 
} /* if the last copy of foo goes out of scope, the memory is automatically freed */ 

अगले सी ++ मानक (आमतौर पर सी ++ 1x और C++ 0x कहा जाता है) std::shared_ptr शामिल होंगे: एक बेहतर है, फिर भी आसान है, जिस तरह से ऊपर करने के लिए, को बढ़ावा देने :: shared_ptr उपयोग करने के लिए है। वहां, आप std::unique_ptr<T> का उपयोग करने में भी सक्षम होंगे जो तेज़ है, क्योंकि यह प्रतिलिपि बनाने की अनुमति नहीं देता है। सी ++ 0x में कंटेनर के साथ std::unique_ptr का उपयोग ptr_container लाइब्रेरी में बढ़ावा देने के समान है।

Answer 2

निश्चित रूप से एक मानक कंटेनर में पॉइंटर को इंगित करने की गलती नहीं है (हालांकि यह auto_ptr का कंटेनर बनाने की गलती है)। हां, आपको व्यक्तिगत तत्वों द्वारा इंगित स्मृति को मुक्त करने के लिए स्पष्ट रूप से हटाने की आवश्यकता है, या आप smart pointers को बढ़ावा देने में से एक का उपयोग कर सकते हैं।

Answer 3

दूसरा विकल्प बूस्ट Pointer Containers का उपयोग करना है। वे वही करने के लिए डिज़ाइन किए गए हैं जो आप चाहते हैं।

Answer 4

वैकल्पिक रूप से boost :: ptr_vector container है।

यह जानता है कि यह पॉइंटर्स धारण कर रहा है कि इसका स्वामित्व है और इस प्रकार ऑटो उन्हें हटा देता है।

एक अच्छी तरफ प्रभाव के रूप में, तत्वों तक पहुंचने पर यह ऑब्जेक्ट का संदर्भ देता है कि कोड को अच्छा दिखने के लिए सूचक नहीं है।

Foo *f = new Foo(); 
boost::ptr_vector<Foo> vect; 
vect.push_back(f); 
// do stuff 
vect.erase(f); 

Answer 5

वेक्टर इसमें मौजूद डेटा को हटा देता है। चूंकि आपके वेक्टर में पॉइंटर्स होते हैं, यह केवल पॉइंटर्स को हटा देता है, न कि वह डेटा जो वे इंगित कर सकते हैं या नहीं।

यह सी ++ में एक सुंदर सामान्य नियम है कि स्मृति जारी की गई है जहां इसे आवंटित किया गया था। वेक्टर ने जो भी पॉइंटर्स इंगित किया है उसे आवंटित नहीं किया है, इसलिए इसे इसे जारी नहीं करना चाहिए।

आपको शायद अपने वेक्टर में पॉइंटर्स को पहले स्थान पर स्टोर नहीं करना चाहिए। कई मामलों में, आप कुछ इस तरह के साथ बंद बेहतर होगा:

vector<Foo> vect; 
vect.push_back(Foo()); 
// do stuff 
vect.erase(f); 

बेशक यह मानता है कि फू copyable है, और इसकी प्रतिलिपि निर्माता भी महंगा नहीं है कि, लेकिन यह मेमोरी लीक से बचा जाता है, और आप डॉन फू ऑब्जेक्ट को मिटाना याद रखना नहीं है। एक और दृष्टिकोण स्मार्ट पॉइंटर्स (जैसे बूस्ट के साझा_पीटीआर) का उपयोग करना होगा, लेकिन आपको पॉइंटर सेमेन्टिक्स की आवश्यकता नहीं हो सकती है, इस मामले में सरल समाधान सबसे अच्छा है।

Answer 6

एसटीएल कंटेनर आपकी याददाश्त को मुक्त नहीं करेंगे।सबसे अच्छी सलाह स्मार्ट पॉइंटर्स का उपयोग कर रही है, यह जानकर कि std :: auto_ptr कंटेनरों के अंदर फिट नहीं होगा। मैं boost :: shared_ptr को बढ़ावा देने की सलाह दूंगा, या यदि आपके कंपाइलर विक्रेता को TR1 एक्सटेंशन (कई करते हैं) के लिए समर्थन है तो आप std :: tr1 :: shared_ptr का उपयोग कर सकते हैं।

यह भी ध्यान रखें कि वेक्टर पॉइंटर के लिए आरक्षित आंतरिक मेमोरी को भी मुक्त नहीं करेगा। std :: vectors कभी भी कॉल करने के लिए कॉल के साथ भी डाउनसाइज नहीं करते हैं()। यदि आपको एक वेक्टर को डाउनसाइज करने की आवश्यकता है तो आपको एक और वेक्टर बनाने और सामग्री को स्वैप करने का सहारा लेना होगा।

Answer 7

स्पष्ट क्यों सूचक को हटाया नहीं जाता है,

std::vector<char const*> strings; 
strings.push_back("hello"); 
strings.push_back("world"); 
// .erase should not call delete, pointers are to literals 

std::vector<int*> arrays; 
strings.push_back(new int[10]); 
strings.push_back(new int[20]); 
// .erase should call delete[] instead of delete 

std::vector<unsigned char*> raw; 
strings.push_back(malloc(1000)); 
strings.push_back(malloc(2000)); 
// .erase should call free() instead of delete 

सामान्य तौर पर, vector<T*>::erase पर विचार लगता है कि नहीं कर सकते कि आप एक T* के निपटान होता है।