दिलचस्प पोस्ट
अजगर के भीतर से कमांड लाइन प्रोग्राम निष्पादित करना एंड्रॉइड: बॉटम पर टैब जर्सी / * सर्वलेट मैपिंग के कारण 404 त्रुटि स्थिर संसाधनों के लिए होती है 32 बनाम 64 बिट सी ++ में निर्धारित करना CreateProcess त्रुटि क्यों देता है 1 9 3 (% 1 वैध Win32 ऐप नहीं है) आरईपी क्या सेटअप करता है? आर में लूप ऑपरेशन को गति दें एक स्कूल असाइनमेंट के लिए नेट के साथ एक रोबोडोडा प्रकार के खेल का विकास करना विदेशी आर्किटेक्चर मानकों समितियों के बारे में परवाह है मैं कैसे एक फ़ाइल को कक्षा पथ में सहेज सकता हूँ Django Admin – बदलें हेडर 'Django Administration' टेक्स्ट अपने वर्तमान मूल्य के आधार पर मोंगोडीबी में एक मूल्य अपडेट करें नई लाइन के साथ जावास्क्रिप्ट स्ट्रिंग – लेकिन \ n उपयोग नहीं कर रहा है PHP मेल ने काम करना बंद कर दिया मैं ggplots के एक 'असंतुलित' ग्रिड कैसे प्राप्त कर सकता हूं?

जब "वस्तु के बाहर" कोई वस्तु है?

सी ++ में, कब "गुंजाइश के बाहर" परिभाषित वस्तु है?

अधिक विशेष रूप से, अगर मुझे एक अकेले लिंक की सूची थी, तो एक सूची सूची नोड ऑब्जेक्ट को "स्कोप से बाहर" के रूप में परिभाषित किया जाएगा? या यदि कोई वस्तु मौजूद है और एक चर 'ptr' से संदर्भित किया जा रहा है, तो क्या यह सही है कि वस्तु को "गुंजाइश से बाहर" के रूप में परिभाषित किया जाता है, जब संदर्भ हटा दिया जाता है या किसी अन्य वस्तु को इंगित करता है?

अद्यतनः किसी ऑब्जेक्ट को मानते हुए एक ऐसा क्लास होता है जिसमें एक क्रियान्वित डिस्ट्रक्टर होता है। क्या नाशक को उस क्षण को कहा जाना चाहिए, जिस वस्तु को दायरे से बाहर निकलता है?

if (myCondition) { Node* list_1 = new Node (3); Node* list_2 = new Node (4); Node* list_3 = new Node (5); list_1->next = list_2; list_2->next = list_3; list_3->next = null; } 

दूसरे शब्दों में, नोड को सूची द्वारा इंगित किया जाएगा- इस विधियों के बाद अपने नाशक को कॉल करें:

नोड * सूची_1 = नया नोड (3);

?

Solutions Collecting From Web of "जब "वस्तु के बाहर" कोई वस्तु है?"

सबसे पहले, याद रखें कि C ++ में ऑब्जेक्ट या तो ढेर पर या ढेर पर बनाया जा सकता है

एक स्टैक फ्रेम (या क्षेत्र) एक बयान द्वारा परिभाषित किया गया है यह एक फंक्शन के रूप में बड़ा या प्रवाह नियंत्रण ब्लॉक ( while / if / for आदि) के रूप में छोटा हो सकता है। एक मनमानी {} जोड़ी कोड के एक मनमाना ब्लॉक को संलग्न करने में भी एक स्टैक फ्रेम का गठन करता है एक फ्रेम के भीतर परिभाषित किसी भी स्थानीय चरणीय क्षेत्र से बाहर हो जाएगा, जब कार्यक्रम उस फ्रेम से बाहर निकल जाएंगे जब एक स्टैक चर का दायरा खत्म हो जाता है, तो उसके नाशक को कहा जाता है।

तो यहां एक स्टैक फ्रेम (फ़ंक्शन के निष्पादन) का एक उत्कृष्ट उदाहरण है और इसके भीतर घोषित स्थानीय वैरिएबल है, जो स्टैक फ़्रेम के बाहर निकल जाने पर एक बार गुंजाइश से बाहर हो जाएगा – फ़ंक्शन खत्म होने पर:

 void bigSideEffectGuy () { BigHeavyObject b (200); b.doSomeBigHeavyStuff(); } bigSideEffectGuy(); // a BigHeavyObject called b was created during the call, // and it went out of scope after the call finished. // The destructor ~BigHeavyObject() was called when that happened. 

यहां एक उदाहरण है जहां हम एक स्टैक फ्रेम देखते हैं जो सिर्फ एक बयान है।

 if (myCondition) { Circle c (20); c.draw(); } // c is now out of scope // The destructor ~Circle() has been called 

फ़्रेम के बाहर आने के बाद स्टैक-निर्मित ऑब्जेक्ट के लिए "दायरे में रहना" का एकमात्र तरीका यह है कि क्या यह किसी फ़ंक्शन का रिटर्न मान है। लेकिन यह वास्तव में "गुंजाइश में शेष" नहीं है क्योंकि वस्तु की नकल की जा रही है। तो मूल दायरे से बाहर हो जाता है, लेकिन एक प्रतिलिपि बनाई जाती है। उदाहरण:

 Circle myFunc () { Circle c (20); return c; } // The original c went out of scope. // But, the object was copied back to another // scope (the previous stack frame) as a return value. // No destructor was called. 

अब, ढेर पर एक ऑब्जेक्ट भी घोषित किया जा सकता है। इस चर्चा की खातिर, मेमोरी के अनाकार के रूप में ढेर के बारे में सोचो। ढेर के विपरीत, जो स्वचालित रूप से आवंटित स्मृति आवंटित करता है और जैसे-जैसे आप दर्ज करते हैं और स्टैक फ्रेम से बाहर निकलते हैं, आपको मैन्युअल रूप से आरक्षित और मुक्त ढेर मेमोरी की आवश्यकता होती है।

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

एक बार जब आप इसके साथ किया जाए तो हेप ऑब्जेक्ट को मुक्त करना आपकी ज़िम्मेदारी है। delete कीवर्ड के साथ आप मुफ्त ढेर ऑब्जेक्ट्स जब तक आप ऑब्जेक्ट को मुक्त नहीं करते हैं, एक हेप ऑब्जेक्ट पर डिस्ट्रक्टर नहीं कहा जाता है।

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

इसके बारे में सोचें: स्टैक पर बनाई गई वस्तु एक कमरे में एक कुर्सी पर टैप किए जाने वाले गुब्बारे की तरह है। जब आप कमरे से बाहर निकलते हैं, तो गुब्बारे स्वचालित रूप से पॉप होती हैं। ढेर पर बनाई गई वस्तु रिबन पर गुब्बारे की तरह है, एक कमरे में एक कुर्सी से बनी हुई है। रिबन सूचक है जब आप कमरे से निकलते हैं, तो रिबन स्वतः गायब हो जाती है, लेकिन गुब्बारा छत पर तैरता है और अंतरिक्ष लेता है। उचित प्रक्रिया है एक पिन के साथ गुब्बारा पॉप, और फिर कमरे से बाहर निकलें, जहां रिबन गायब हो जाएगा। लेकिन, स्ट्रिंग पर गुब्बारे के बारे में अच्छी बात यह है कि आप रिबन को भी खोल सकते हैं, इसे अपने हाथ में रख सकते हैं, और कमरे से बाहर निकल सकते हैं और आप के साथ गुब्बारे ले सकते हैं।

तो आपकी लिंक की गई सूची में जाने के लिए: आमतौर पर, ऐसी सूची के नोड को ढेर पर घोषित किया जाता है, प्रत्येक नोड के साथ अगले नोड पर पॉइंटर रखता है। यह सब ढेर पर बैठा है और कभी भी गुंजाइश नहीं जाता है। केवल एक चीज जो गुंजाइश से बाहर निकल सकती है सूचक है जो सूची की जड़ को इंगित करता है – सूचक जो आप सूची में पहले स्थान पर संदर्भ के लिए उपयोग करते हैं। यह दायरे से बाहर जा सकते हैं

यहां ढेर पर सामान बनाने का एक उदाहरण है, और रूट से बाहर जा रहा रूट सूचक:

 if (myCondition) { Node* list_1 = new Node (3); Node* list_2 = new Node (4); Node* list_3 = new Node (5); list_1->next = list_2; list_2->next = list_3; list_3->next = null; } // The list still exists // However list_1 just went out of scope // So the list is "marooned" as a memory leak 
 { //scope is defined by the curly braces std::vector<int> vec; } // vec is out of scope here! vec.push_back(15); 

"गुंजाइश से बाहर" एक सामंजस्य है: जैसा कि, एक अवधारणा के नाम या शब्दावली का उपयोग करना, कुछ करीबी से संबंधित लेकिन अलग-अलग बातों के बारे में बात करने के लिए

सी ++ में एक गुंजाइश कार्यक्रम पाठ का एक स्थैतिक क्षेत्र है, और इतना कुछ "गुंजाइश के बाहर", शब्दशः लिया जाता है, जिसका अर्थ है पाठ के किसी क्षेत्र के बाहर शारीरिक रूप से। उदाहरण के लिए, { int x; } int y; { int x; } int y; : y का घोषणापत्र उस क्षेत्र से बाहर है जिसमें x दिखाई दे रहा है।

"गुंजाइश से बाहर निकलने" का प्रयोग इस विचार को व्यक्त करने के लिए किया जाता है कि कुछ गुंजाइश से जुड़ा वातावरण का गतिशील सक्रियण / तत्काल समाप्त हो रहा है। और इसलिए उस गुंजाइश में परिभाषित वेरिएबल्स दूर जा रहे हैं (इस प्रकार "गुंजाइश से बाहर")

वास्तव में "गुंजाइश से बाहर" क्या हुआ है, निर्देश सूचक है, इसलिए बोलना; कार्यक्रम का मूल्यांकन अब एक ऐसी जगह में हो रहा है जिसमें किसी के लिए कोई दृश्यता नहीं है। लेकिन एक गुंजाइश में सब कुछ खत्म हो जाता है! स्थैतिक चर अब भी अगली बार जब दायरा दर्ज हो जाएगा।

"गुंजाइश से बाहर जाना" बहुत सटीक नहीं है, लेकिन कम है और हर कोई इसका अर्थ समझता है।

किसी ऑब्जेक्ट को फ़ंक्शन के अंदर घोषित किया जाता है (या फ़ंक्शन के अंदर कुछ घुंघराले-ब्रेस-ब्रैकेट युक्त कवच के अंदर) दायरे से बाहर हो जाता है जब निष्पादन कोड का वह हिस्सा छोड़ देता है।

 void some_func() { std::string x("Hello!"); // x is in scope here } // But as soon as some_func returns, x is out of scope 

यह स्टैक पर घोषित सामान पर ही लागू होता है, इसलिए इसे अकेले-लिंक्ड सूचियों के साथ कुछ नहीं करना पड़ता है, क्योंकि सूची नोड्स आमतौर पर new साथ ढेर पर इंस्टीट्यूट हो जाते हैं।

इस उदाहरण में, new द्वारा लौटा संकेतक दायरे से बाहर निकलेगा, जब फ़ंक्शन निकलता है, लेकिन नोड पर कुछ भी नहीं होगा:

 void make_a_node() { Node* p = new Node; } // Oh noes a memory leak! 

जब यह गुंजाइश छोड़ देता है जिसे इसे घोषित किया गया था 🙂

आपके प्रश्न के रूप में यह खड़ा है, कार्यान्वयन को देखे बिना उत्तरदायी नहीं है। यह नीचे आता है जहां आप इस नोड को घोषित करते हैं।

 void Foo() { int i = 10; { int j = 20; } // j is out of scope } // i is out of scope