Is object created without new operator deleted in a specific case in C++ -

अगर हमारे पास निम्न कोड स्निपेट है:

  MyObject my_object = MyObject (0); My_object = MyObject (1);   
 MyObject (0) का क्या होता है? क्या इसे हटा दिया गया है? मैंने इसके बारे में क्या पढ़ा है इसे देखते हुए इसे केवल तब ही हटाया जाना चाहिए जब हम निर्माण के दायरे को छोड़ दें, तो संभवतः एनवेडर नहीं। यदि ऐसा है तो क्या यह स्पष्ट रूप से पॉइंटर्स इस्तेमाल करने के अलावा अन्य को हटाने का कोई तरीका है?   
 
 
 शब्द < कोड> हटाएं  का सी + + में एक विशेष अर्थ है, इसलिए  हटाए गए  का उपयोग दुर्भाग्यपूर्ण है।  
  MyObject my_object = MyObject (0);   
 यह रेखा घोषित करता है कि स्वत: भंडारण अवधि (अर्थात, स्टैक पर) के साथ एक प्रकार का ऑब्जेक्ट  MyObject  बनाया गया है। यह उद्देश्य नष्ट हो जाएगा (यानी, इसका नाशक निष्पादित किया जाएगा) जब दायरे समाप्त होती हैं संबंधित मेमोरी के स्मरण के लिए मानक में कोई प्रावधान नहीं किया गया है (बाद में देखें)।  
 इस ऑब्जेक्ट प्रकार  MyObject  अभिव्यक्ति का उपयोग कर बनाया जाएगा  MyObject ( 0) । यह कन्स्ट्रक्टर अपनी विशेष उपयोग के लिए अलग-अलग सेट की गई स्मृति को इनिशियलाइज़ करेगा।  
  नोट: वास्तव में, एक अस्थायी बनाया जा सकता है और प्रतिलिपि कन्स्ट्रक्टर तब बुलाया जाता है, लेकिन अधिकांश संकलक इस मध्यवर्ती कदम से बचता है, शुक्र है, क्योंकि मानक विशेष रूप से इसे अनुमति देता है।   
  my_object = MyObject (1);   
 यह पंक्ति पहले से मौजूद  my_object  ऑब्जेक्ट के लिए अभिव्यक्ति  MyObject (1)  द्वारा निर्धारित एक नया मान प्रदान करती है ऐसा करने के लिए, एक अस्थायी प्रकार  MyObject  स्वचालित संग्रहण अवधि के साथ बनाया गया है। उसके बाद, असाइनमेंट ऑपरेटर निष्पादित होता है; अगर अतिभारित नहीं होता तो यह अस्थायी स्थिति को  my_object  में कॉपी कर देगा, यह मिटाकर कि पिछली स्थिति क्या थी अभिव्यक्ति के अंत में, अस्थायी नष्ट हो जाता है (एक बार फिर, संबंधित स्मृति के स्मरण के लिए कोई सिद्ध नहीं किया जाता है)।  
  नोट:  MyObject (0)  "नष्ट" नहीं है, क्योंकि यह अस्तित्व में नहीं है, इसके बजाए इसके राज्य को याद किए गए स्मृति को  MyObject (1)  से राज्य की प्रतिलिपि बनाने के लिए पुन: उपयोग किया गया है।   < Hr> 
 जैसा कि वादा किया गया है, क्योंकि यह आपकी चिंता की बात है, स्मृति पहलुओं पर चर्चा यह संकलक विशिष्ट है, लेकिन अधिकांश संकलक भी इसी तरह व्यवहार करते हैं।  
 मान लें कि हमारे पास निम्न फ़ंक्शन हैं:  
  शून्य f () {MyObject my_object = MyObject (0); {My_object = MyObject (1); do_something (my_object); } {My_object = MyObject (2); do_something (my_object); }}   
 स्टैक पर कितना स्थान की आवश्यकता है?  
 
 हम मानते हैं कि यह पहली पंक्ति पर प्रत्यक्ष निर्माण करता है  
 हम कंपाइलर को मानते हैं कि स्टैक पिक्चर (नाराज़, उदाहरण के लिए नहीं) करने के लिए पर्याप्त स्मार्ट नहीं है   
 उन धारणा के साथ, यह 3  MyObject  के लिए स्थान की आवश्यकता है  
 
  MyObject my_object = MyObject (0); :  my_object  फ़ंक्शन के अंत तक लाइव रहते हैं  
 < कोड> my_object = MyObject (1); : एक अस्थायी आवश्यकता बनानी  
  my_object = MyObject (2); : एक अस्थायी आवश्यकता बनानी   
 यदि कंपाइलर स्टैक रंगाई करने के लिए पर्याप्त स्मार्ट था, तो दो अस्थायी (जो एक साथ कभी आवश्यकता नहीं होती) हो सकता है उसी स्मृति स्थान का उपयोग करें, इस प्रकार अंतरिक्ष की आवश्यकता को 2  MyObject  को कम किया जा रहा है।  
 एक स्मार्ट अनुकूलक संभवतः, सीधे  MyObject (1)  और  MyObject (2)  सीधे  my_object  में (अगर यह साबित हो सकता है कि प्रभाव अस्थायी बनाने और उसके बाद की प्रतिलिपि बनाने की तुलना में ही होगा), इस प्रकार कम करना अंतरिक्ष की आवश्यकता 1  MyObject ।  
 अंत में, यदि  do_something  की परिभाषा दिखाई दे रही है, और यह इसके पैरामीटर का उपयोग नहीं करती है, तो निश्चित शर्तों के तहत यह (सिद्धांत में) पूरी तरह से  my_object  के निर्माण को बाईपास कर सकता है। इस प्रकार के अनुकूलन सरल कार्यक्रमों के साथ गवाह हो सकते हैं जैसे:  
  int main () {int i = 0; (; I & lt; 1000; ++ i) के लिए; वापसी i; }   
 जो तुच्छ रूप से अनुकूलित हैं:  
  int main () {return 1000; }   
 (ध्यान दें कि  i  गायब हो गया है)  
 जैसा कि आप देख सकते हैं ... यह वास्तव में बहुत मुश्किल है कि संकलक / अनुकूलक कर सकेंगे। अगर आपके पास वास्तव में तंग मेमोरी की आवश्यकता है, तो (शायद आश्चर्यजनक रूप से), आपकी सबसे अच्छी शर्त फ़ंक्शंस से ब्लॉक को बदल सकती है।