'इसे हटाएं;' कथन के दौरान क्या हो रहा है? निम्नलिखित दो विकल्पों में</p> <pre><code>class foo { public: foo(){} ~foo(){} void done() { delete this;} private: int x; }; </code></pre> <p>क्या हो रहा है (और यह वैध है?):

Question

निम्नलिखित कोड पर विचार करें

विकल्प 1:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
    delete a; 
} 

विकल्प 2:

void main() 
{ 
    foo a; 
    a.done(); 
} 

दूसरा delete a; कथन चुनने पर कथन होगा आयन 1 अपवाद या ढेर भ्रष्टाचार का कारण बन जाएगा?

विकल्प 2 अपवाद या ढेर भ्रष्टाचार का कारण बन जाएगा?

Answer 1

delete this; की अनुमति है, यह ऑब्जेक्ट हटा देता है।

आपके कोड स्निपेट दोनों में अपरिभाषित व्यवहार है - पहले मामले में पहले से हटाए गए ऑब्जेक्ट को हटा दिया गया है, और दूसरे मामले में स्वत: संग्रहण अवधि के साथ ऑब्जेक्ट को हटाया जा रहा है।

चूंकि व्यवहार अपरिभाषित है, मानक यह नहीं कहता कि वे अपवाद या ढेर भ्रष्टाचार का कारण बनेंगे या नहीं। विभिन्न कार्यान्वयन के लिए यह या तो हो सकता है, न तो, या दोनों, और जब भी आप कोड चलाते हैं तो यह समान हो सकता है या नहीं भी हो सकता है।

Answer 2

दोनों एक त्रुटि का कारण बनेंगे।

पहले सूचक त्रुटि पैदा जबकि दूसरा एक ढेर पर आवंटित किया जाता है दूसरा delete साथ दो बार नष्ट कर दिया जाता है, और परोक्ष हटाया नहीं जा सकता (त्रुटि नाशक के पहले मंगलाचरण के कारण)।

Answer 3

दोनों एक त्रुटि का कारण होता है, क्या आप चाहते हैं:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
} 

कौन सा संकलक नीचे की तरह कुछ, मुझे आशा है कि जो "इस" थोड़ा कम भ्रामक को हटाने बनाता है करने के लिए विस्तार होगा।

void __foo_done(foo* this) 
{ 
    delete this; 
} 

void main() 
{ 
    foo* a = new foo(); 
    __foo_done(a); 
} 

भी देखें, Is it legal (and moral) for a member function to say delete this?

Answer 4

delete this कॉलिंग एक बुरा विचार है। जो भी new पर कॉल करता है उसे delete पर कॉल करना चाहिए। इसलिए अन्य प्रतिक्रियाओं में हाइलाइट की गई समस्याएं।

ऑब्जेक्ट्स की सरणी को समझते समय भी आप मेमोरी लीक/अपरिभाषित व्यवहार कर सकते हैं।

Answer 5

दोनों मामलों में आपका ढेर दूषित हो जाएगा। बेशक, आप विकल्प 2 "->" में उपयोग नहीं कर सकते हैं यदि बाएं मान (इस मामले में, "ए") एक सूचक नहीं है, विकल्प 2 में सही रूप a.done() होगा; लेकिन हाँ, अगर आप 1 को हटाने की कोशिश करते हैं तो आपको ढेर भ्रष्टाचार होना चाहिए 1) पहले से हटा दिया गया है, या 2) स्थानीय चर।

कॉलिंग "इसे हटाएं" तकनीकी रूप से मान्य है और स्मृति को मुक्त करता है।

संपादित मैं उत्सुक था और वास्तव में इस की कोशिश की:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this; } 
    void test() { x = 2; } 
    int getx() { return x; } 
private: 
    int x; 
} ; 


int main(int argc, char* argv[]) 
{ 
    foo *a = new foo(); 
    a->done(); 
    a->test(); 
    int x = a->getx(); 
    printf("%i\n", x); 
    return x; 
} 

printf को एक कॉल सफल होगा, और x मूल्य 2 का आयोजन करेगा।

Answer 6

मैं उस संदर्भ के बारे में बहुत सावधान रहूंगा जिसमें आप मुफ्त मेमोरी हैं। कॉल करते समय "इसे हटाएं;" वर्ग संरचना से जुड़े स्मृति को मुक्त करने का प्रयास करेगा, कि ऑपरेशन का मूल स्मृति आवंटन के संदर्भ को कम करने का कोई साधन नहीं है, यानी, अगर इसे ढेर या ढेर से आवंटित किया गया है। मेरी सलाह आपके कोड को फिर से काम करना होगा ताकि डेलोकेशन ऑपरेशन को बाहरी संदर्भ से बुलाया जा सके। ध्यान दें कि यह कक्षा में आंतरिक संरचनाओं को अलग करने से अलग है, उस स्थिति में, विनाशक का उपयोग करें।

Answer 7

इस प्रश्न का उत्तर दिया गया है, लेकिन मैं एक नया मुद्दा जोड़ूंगा कि यदि आपकी कक्षा कॉल को हटा देती है तो आपको विनाशक को भी निजी बनाना चाहिए।

यह सुनिश्चित करता है कि केवल वर्ग ही खुद को हटा सके।

यदि आप अपने विनाशक को निजी बनाते हैं, तो आपके दोनों कोड नमूने संकलित करने में असफल हो जाएंगे।