ऑपरेटर और सरणी हटाएं?

Question

मेरे पास abstractBase कक्षा और Derived कक्षा है।

int main() 
{ 
    Base *arrayPtr[3]; 

    for (int i = 0; i < 3; i++) 
    { 
    arrayPtr[i] = new Derived(); 
    } 

    //some functions here 

    delete[] arrayPtr; 

    return 0; 
} 

मुझे यकीन नहीं है कि डिलीट ऑपरेटर का उपयोग कैसे करें। यदि मैं उपरोक्त दिखाए गए बेस क्लास पॉइंटर्स की सरणी हटा देता हूं, तो क्या यह कॉल क्लास ऑब्जेक्ट्स को नष्ट कर देगा और मेमोरी को साफ करेगा?

Answer 1

आप अपने सरणी के तत्वों, delete उनमें से प्रत्येक से अधिक पुनरावृति करना है। फिर delete [] को सरणी पर कॉल करें यदि इसे गतिशील रूप से new[] का उपयोग करके आवंटित किया गया है।

अपने नमूना कोड में, सरणी को स्टैक पर आवंटित किया जाता है ताकि आपको delete [] पर कॉल न करना पड़े।

यह भी सुनिश्चित करें कि आपके Base कक्षा में virtual विनाशक है।

संदर्भ: When should my destructor be virtual।

Answer 2

नहीं, आप स्पष्ट रूप से सरणी में प्रत्येक आइटम को हटाना होगा:

for (int i = 0; i < 3; ++i) 
{ 
    delete arrayPtr[i]; 
} 

Answer 3

इसके बजाय आप क्या करना चाहिए:

for (int = i; i < 3; i++) 
{ 
    delete arrayPtr[i]; 
} 

और तुम delete[] arrayPtr; ऐसा नहीं करना चाहिए जैसा कि आप मुक्त करने के लिए कोशिश कर रहे हैं/एक ढेर arrayPtr आवंटित हटा दें।

विचार करने की एक और बात एक सरणी के बजाय पॉइंटर्स के std::vector का उपयोग कर रही है। और यदि आप एक कंपाइलर का उपयोग कर रहे हैं जो TR1 लागू करता है, तो आप कच्चे पॉइंटर्स के बजाय std::tr1::shared_ptr के std::vector का भी उपयोग कर सकते हैं, और आपको उन वस्तुओं को स्वयं हटाने के बारे में चिंता करने की आवश्यकता नहीं होगी।

उदाहरण:

{ 
    std::vector< std::tr1::shared_ptr<Base> > objects; 
    for (int i=0; i < 3; ++i) 
    { 
     objects.push_back(std::tr1::shared_ptr<Base>(new Derived())); 
    } 
} // here, once "objects" exit scope, all of your Derived objects are nicely deleted 

Answer 4

यकीन Base एक आभासी नाशक है बनाओ। फिर fretje outlined की तरह, सरणी में प्रत्येक तत्व को हटाएं, फिर सरणी हटाएं।

आपको सरणी के लिए std::vector का उपयोग करना चाहिए। उस ने कहा, आपको वास्तव में इस तरह की चीज़ के लिए बने कंटेनर का उपयोग करना चाहिए। (इसलिए आप सभी तत्वों को गलती से विफल नहीं करते हैं, जो निश्चित रूप से मामला होगा यदि कोई अपवाद फेंक दिया जाता है!) बूस्ट में such a library है।

Answer 5

आपको व्यक्तिगत रूप से सरणी के सदस्यों को हटाना होगा। आपको यह भी सुनिश्चित करना होगा कि आपकी बेस क्लास में वर्चुअल विनाशक है। आप इसे मजबूत पॉइंटर्स के एक सरणी (या बेहतर अभी भी एक std :: वेक्टर) बनाने पर विचार करना चाहेंगे, जैसे boost :: shared_ptr।

Answer 6

नहीं, आप ऐसा नहीं कर सकते हैं। जैसा कि अन्य ने सुझाव दिया है कि आपको प्रत्येक आइटम से गुज़रना होगा और इसे हटा देना होगा। यह याद रखने के लिए एक बहुत ही सरल नियम है। आप new का उपयोग कर आवंटित तो delete उपयोग करते हैं, और यदि आप new[] का इस्तेमाल किया था तो का उपयोग delete[]

Answer 7

नहीं, यह काफी आप क्या चाहते हैं नहीं करता है।

वहाँ दो अंक यहाँ के लिए बाहर देखने के लिए कर रहे हैं:

1. वाक्य रचना अगर आप गतिशील सरणी आवंटित delete[] arrayPtr प्रयोग किया जाता है, इस तरह:

   arrayPtr = new (Base *)[mylength]; 
   

   अपने मामले में, तथापि, आप एक स्थाई आवंटित सरणी है, इसलिए इसे हटाने की कोई आवश्यकता नहीं है। हालांकि, आप सरणी में अलग-अलग तत्वों को हटाने की आवश्यकता है:

   class Base 
   { 
       virtual ~Base(); 
       /* ... */ 
   }; 
   

   :

   for (int = i; i < 3; i++) 
       delete arrayPtr[i]; 
   

2. दूसरी बात आप देखभाल करने के लिए वर्ग के नाशक Base आभासी बनाने के लिए है की जरूरत है यह सुनिश्चित करता है कि जब आप Base * पर हटाते हैं जो वास्तव में Derived पर इंगित करता है, तो Derived के विनाशक को केवल Base का विनाशक कहा जाता है।

Answer 8

सूचना क्या अनुपस्थित है:

int main() { 
    boost::ptr_vector<Base> v; 
    for (int i = 0; i < 3; i++) v.push_back(new Derived()); 
    // some functions here, using v[0] through v[2] 
} 

चेक Boost's pointer containers बाहर।

Answer 9

ऑपरेटर हटाएं उस सूचक पर नए ऑपरेटर से मेल खाना चाहिए, अगर इसे new[] के साथ आवंटित किया गया था, तो आपको delete[] और इसके विपरीत कॉल करना होगा;

int* pInt = new int; 
delete pInt; OK 
delete [] pInt; WRONG 

int[] pIntArr = new int[3]; 
delete [] pIntArr; OK 
delete pIntArr; WRONG 

आपके मामले में वहाँ कुछ और गलत है - आप delete कि ढेर पर आवंटित किया गया था की कोशिश कर रहे हैं। वह काम नहीं करेगा।

आपको इस विशेष मामले में प्रत्येक सूचक को अलग-अलग हटा देना होगा।

Answer 10

आपके पास क्या है अपरिभाषित व्यवहार - एक बग। new पर प्रत्येक कॉल को delete से मिलान करने की आवश्यकता है; new[] पर प्रत्येक कॉल को delete[] से मिलान करने की आवश्यकता है। दोनों अलग हैं और मिश्रित नहीं किए जा सकते हैं।

आपके द्वारा पोस्ट किए गए कोड में, आपके पास स्टैक पर आवंटित बेस पर पॉइंटर्स की एक सरणी है। फिर आप स्टैक पर आवंटित सरणी पर delete[] पर कॉल कर रहे हैं - आप ऐसा नहीं कर सकते हैं। आप केवल delete[]new[] के साथ ढेर पर आवंटित एक सरणी कर सकते हैं।

आप प्रत्येक तत्व new साथ आवंटित के लिए delete के लिए एक कॉल की जरूरत है - या अधिमानतः, एक कंटेनर वर्ग, जैसे std::vector का उपयोग कर के बजाय एक सरणी का उपयोग कर इस पर गौर।

Answer 11

आप प्रतिमान मिश्रण कर रहे हैं - सरणी डिलीट ऑपरेटर को सरणी नए ऑपरेटर द्वारा आवंटित स्मृति मुक्त करने के लिए डिज़ाइन किया गया है, लेकिन आप स्टैक पर पॉइंटर्स की सरणी के रूप में अपनी सरणी आवंटित कर रहे हैं और फिर प्रत्येक सरणी के लिए ऑब्जेक्ट आवंटित कर रहे हैं सदस्य। आपके कोड में, आपको सरणी के माध्यम से पुनरावृत्त करने की आवश्यकता है।

सरणी नए ऑपरेटर का उपयोग करने के लिए, अगर आप इस तरह की घोषणा करेंगे:

Base *array; 
array = new Base[3]; 
/* do stuff */ 
delete[] array; 

इस तीन वस्तुओं के लिए एक सन्निहित स्मृति क्षेत्र आवंटित - ध्यान दें कि आप बेस में ऑब्जेक्ट की श्रृंखला मिल गया है, नहीं बेस ऑब्जेक्ट्स के पॉइंटर्स की एक सरणी।