क्यों कोड का नीचे का टुकड़ा क्रैश नहीं हो रहा है, हालांकि मैंने ऑब्जेक्ट को हटा दिया है?

Question

class object 
{ 
    public: 
    void check() 
    { 
     std::cout<<"I am doing ok..."<<std::endl; 
    } 
}; 

int main() 
{ 
    object *p = new object; 
    p->check(); 
    delete p; 
    p->check(); 
    delete p; 
    p->check(); 
} 

संपादित: गुरुओं, मैं "या यह क्रैश हो सकता है नहीं हो सकता है" बयान के कई से उलझन में हूँ .. क्यों नहीं है वहाँ कहने के लिए एक मानक है, हम स्मृति का एक ब्लॉक के साथ यह कैसे सौदा हटा दी जाती है कि 'डिलीवरी ऑपरेटर' का उपयोग कर ..? कोई इनपुट?

Answer 1

क्या यह वास्तव में की तरह के बाद संकलक अपनी तरह से किया गया है लग रहा है कुछ इस तरह है क्योंकि:

object::check(object* this) 
{ 
    // do stuff without using this 
} 

int main() 
{   
    object *p = new object; 
    object::check(p); 
    delete p; 
    object::check(p); 
    delete p; 
    object::check(p); 
} 

आप के बाद से इस "स्पर्श नहीं कर रहे", आप वास्तव में किसी भी खराब स्मृति का उपयोग नहीं करते हैं।

हालांकि, पी दो बार को हटाने के लिए एक दुर्घटना का कारण करने के लिए सक्षम होना चाहिए:

http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.2

Answer 2

क्योंकि फ़ंक्शन ऑब्जेक्ट के सदस्य डेटा या this पॉइंटर के साथ कुछ भी नहीं कर रहा है।

यह self तर्क के रूप में गलत सूचक के साथ एक समारोह

void check(object *self) 
{ 
    std::cout<<"I am doing ok..."<<std::endl; 
} 

बुला की तरह है।

हालांकि एक डबल डिलीट है, जो कुछ वातावरण में क्रैश हो सकता है।

Answer 3

मुझे लगता है कि यह पर्यावरण (प्लेटफार्म/कंपाइलर) पर निर्भर करता है ...
यह कम से कम अप्रत्याशित व्यवहार देता है। मुझे लगता है कि तुम भाग्यशाली है कि यह अपने मामले ;-) में दुर्घटना नहीं करता है

Answer 4

हटाएं केवल स्मृति deallocates और इसे वापस ढेर करने के लिए उपलब्ध बनाता है।

हटाए जाने के बाद पॉइंटर का मान अपरिभाषित है, इसलिए यह क्रैश हो सकता है।

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

Answer 5

भले ही विधि कॉल इस सूचक का उपयोग कर रहा हो, फिर भी इसे क्रैश करने की गारंटी नहीं दी जाएगी। हटाए जाने पर पॉइंटर पी को शून्य नहीं किया जा रहा है, इसलिए अभी भी स्मृति में एक ही पते को इंगित कर रहा है। नए/डिलीट और ढेर मैनेजर के कार्यान्वयन के आधार पर इस मेमोरी का पुन: उपयोग भी नहीं किया जा सकता है, इसलिए स्मृति का जारी होने के बावजूद पी का उपयोग अभी भी काम जारी रख सकता है।

Answer 6

दूसरों ने जो कहा है उससे थोड़ा जोड़ने के लिए, चेक() विधि के अंदर अपनी कक्षा के सदस्य चर का उपयोग करने का प्रयास करें और फिर देखें कि क्या होता है।

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

संपादित करें: इसके अलावा, यदि आपकी विधि किसी भी सदस्य चर का उपयोग नहीं कर रही है, तो यह एक स्थिर विधि होने के लिए एक निश्चित उम्मीदवार है।

Answer 7

आप नहीं के बराबर संकेत के साथ एक ही है, बस जब तक आप वर्ग उदाहरण के राज्य का उपयोग कभी नहीं कर सकते हैं:

class object 
{ 
    public: 
    void check() 
    { 
     std::cout<<"I am doing ok..."<<std::endl; 
    } 
}; 

int main() 
{ 
    object *p = 0; 
    p->check(); 
} 

Answer 8

यह उससे भी मजेदार है। यह & रन अच्छी तरह से संकलित:

#include <iostream> 
using namespace std; 
class object { 
    public: 
     void check() { 
      cout << "I am doing ok..." << endl; 
     } 
}; 

int main() { 
    object *p = (object*)0; 
    p->check(); 
    return 0; 
} 

खोल करने के लिए पर:

 
$ g++ -o t t.cc 
$ ./t 
I am doing ok... 
$ 

:) आप वास्तव में एक वस्तु इस विधि कॉल करने के लिए नहीं है! चियर्स, ज

Answer 9

1) जीसीसी 4.0.1 के साथ संकलक पर निर्भर करता है, मैक ओएस पर:

g++ -Wall -g -c main.cpp -o main.o 
g++ -o x main.o 
./x 
I am doing ok ... 
I am doing ok ... 
x(5857) malloc: *** error for object 0x100150: double free 
*** set a breakpoint in malloc_error_break to debug 
I am doing ok ... 

डबल मुक्त खड़ी कर रहा है समस्याओं।

2) आम तौर पर हटाए गए पॉइंटर को हटाने से पहले परिभाषित नहीं किया गया है, आपको हमेशा पॉइंटर को हटाने के बाद 0 पर सेट करना चाहिए, पॉइंटर पर मूल्य 0 के साथ कॉल करने की अनुमति है।

3) कारण यह स्ट्रिंग को मुद्रित करने का कारण यह है कि सूचक अभी भी स्मृति को इंगित करता है जिसे अब मुक्त किया गया था, लेकिन मुझे लगता है कि केवल सूचक को पुनः दावा किया गया है। पुन: उपयोग के लिए मुफ्त पूल में लौट आया, स्मृति को अधिलेखित या शून्य नहीं किया गया है, इसलिए यदि आप पॉइंटर को अस्वीकार करते हैं तो आपको अभी भी मूल मान मिलते हैं, जब तक कि इस दौरान स्मृति का पुन: उपयोग नहीं किया जाता है।

Answer 10

हटाएं पी को शून्य पर सेट नहीं करता है, इसलिए यह अभी भी स्मृति स्थान को इंगित करता है। यह नए/हटाए जाने के कार्यान्वयन पर निर्भर करता है लेकिन आम तौर पर किसी भी नए आवंटन के लिए उपलब्ध स्मृति के उस हिस्से को केवल अंक ही हटा देता है।

ऐसा लगता है जब आप अपनी हार्ड्राइव से फ़ाइल हटाते हैं। फ़ाइल सिस्टम बस उस क्षेत्र को उपलब्ध कराता है। फ़ाइल डेटा मौजूद है और तब तक तब तक पुनर्प्राप्त किया जा सकता है जब तक आप नए लिखते नहीं हैं।