C ++: जब किसी वस्तु का जीवनकाल उसके संदर्भ के जीवनकाल द्वारा निर्धारित किया जाता है

उस समय, जब लेख r- मूल्य लिंक की प्रकृति और नुकसान पर प्रकाशित किए जा रहे थे (उपयोगी स्रोतों के लिंक के साथ एक उदाहरण habrahabr.ru/post/157961 ), मुझे संदेह है कि काफी कुछ साधारण एल-मूल्य लिंक की विशेषताओं को नहीं जानते हैं। इस लेख का सार एक उदाहरण दिखाना है जब किसी वस्तु का जीवनकाल उसके लिए एक एल-मूल्य संदर्भ के जीवनकाल द्वारा निर्धारित किया जाता है, और इसका उपयोग कैसे किया जा सकता है। अगर दिलचस्पी है, तो स्वागत है। वैसे, एल-वैल्यू लिंक के बारे में अधिक से अधिक सुविधाओं को जानना, आर-मूल्य को समझना आसान होगा।

हम यह मान सकते हैं कि हर कोई आवश्यकता पड़ने पर एक स्थिर लिंक के माध्यम से वस्तुओं को स्थानांतरित करता है और वे वस्तु के जीवनकाल को काफी सटीक रूप से जानते हैं।
उदाहरण के लिए:

struct S{}; void f(const S& value){} f(S()); 

इस स्थिति में, हम मान सकते हैं कि फ़ंक्शन S () को कॉल करने के बाद ऑब्जेक्ट S () ध्वस्त होना शुरू हो जाएगा। यह बहुत सटीक क्यों है? - क्योंकि, q(A(), B()); सृजन का क्रम और, तदनुसार, ए और बी वस्तुओं को नष्ट नहीं किया गया है। इसके अलावा, हर कोई जानता है कि आप नहीं लिख सकते

 int& r = 1; //   

और अब मज़ेदार हिस्से के लिए।
लेकिन आप ऐसा कर सकते हैं:

 const int& r = 1; 

इस मामले में, मानक और स्ट्रेन्सेप के अनुसार (7.7.1)

• int प्रकार में अंतर्निहित रूपांतरण पहले लागू किया जाता है
• तब मान को int के अस्थायी ऑब्जेक्ट में जोड़ा जाता है
• और अब इस अस्थायी वस्तु का उपयोग हमारे लिंक को आरंभ करने के लिए किया जाता है

यानी निम्नलिखित उदाहरण में

 struct Obj { Obj(int i) : m_i(i) { cout << "ctr: " << m_i << endl; } ~Obj() { cout << "dtr: " << m_i << endl; } Obj operator+(const Obj& value) { return Obj(m_i + value.m_i); } int m_i; }; ... Obj o1(1); const Obj& ro2 = Obj(2) + Obj(3); Obj o6(6); 

• ऑब्जेक्ट O1 बनाया जाएगा
• Obj(2) और Obj(3) (अनुक्रम मानक द्वारा परिभाषित नहीं है)
• एक अस्थायी ऑब्जेक्ट बनाया जाता है जो ro2 इनिशियलाइज़ करता है
• Obj(2) और Obj(3) ध्वस्त Obj(3)
• o6 बनाया जाएगा
• डिस्ट्रक्टर्स को रिवर्स ऑर्डर में बुलाया जाएगा: o5 , और o5

आउटपुट (msvs 2012):

 ctr: 1 ctr: 3 ctr: 2 ctr: 5 dtr: 2 dtr: 3 ctr: 6 dtr: 6 dtr: 5 dtr: 1 

लेकिन यह सब नहीं है। हर कोई यह भी जानता है कि आभासी विध्वंसक की आवश्यकता क्यों है, लेकिन आइए निम्न उदाहरण देखें जब आधार वर्ग में गैर-आभासी विध्वंसक होता है। हम अपने Obj का उपयोग करना और जोड़ना जारी रखते हैं

 struct D : Obj { D(int i) : Obj(i) { cout << "D::ctr: " << m_i << endl; } ~D() { cout << "D::dtr: " << m_i << endl; } }; Obj o1(1); const Obj& ro2 = D(5); Obj o6(6); 

निष्कर्ष:

 ctr: 1 ctr: 5 D::ctr: 5 ctr: 6 dtr: 6 D::dtr: 5 dtr: 5 dtr: 1 

यानी इस मामले में, इस तथ्य के बावजूद कि निरंतर संदर्भ का प्रकार const Obj& , हालांकि, हमारी वस्तु D "जीवन" है, जबकि "संदर्भ" यह "जीवन" है।

फिर सवाल उठता है: "व्यावहारिक उपयोग क्या है?" एक उत्तर यह है कि यह पहले से ही ScopeGuard दृष्टिकोण ( http://www.drdobbs.com/cpp/generic-change-the-way-you-write-excepti/184403758?pgno-2 ) में लागू है। मैं व्यक्तिगत रूप से इस दृष्टिकोण का उपयोग नहीं करेगा और संबंधित विध्वंसक और निर्माणकर्ता के साथ एक वर्ग में वांछित संसाधन संभाल लपेटूंगा।

खैर, छापों के रूप में, और अब अंतर्निहित प्रकार के रूपांतरण के बारे में याद रखें, जब निर्माणकर्ता को स्पष्ट रूप से घोषित नहीं किया गया है, टेम्पलेट कार्यों में प्रकार और पोस्ट की शुरुआत में लेख।

उम्मीद है कि इस लेख ने किसी और के लिए एक और C ++ सुविधा खोल दी है।

परिशिष्ट और टिप्पणियाँ।

उन लोगों को बचाने के लिए जो मानक में नहीं आते हैं और सिर्फ सी ++ प्रोग्रामर शुरू करते हैं, मैं आपको याद दिलाता हूं कि के मामले में

 const Obj& f() {return Obj();} 

फ़ंक्शन से बाहर निकलने से पहले अस्थायी ऑब्जेक्ट को नष्ट कर दिया जाएगा, और लौटा लिंक थोड़ा सा होगा। किसी वस्तु का जीवनकाल केवल स्थानीय लिंक से निर्धारित होता है। मानक की तुलना में अधिक स्पष्ट और स्पष्ट रूप से कहना अधिक कठिन होगा, अगर यह दिलचस्प है, तो पैराग्राफ 12.2 से शुरू करें। यहाँ मानक से एक उद्धरण है (जो सभी प्रकार के बगिल और मंचों में काफी सामान्य है):

दूसरा संदर्भ तब होता है जब एक संदर्भ अस्थायी के लिए बाध्य होता है। अस्थायी जिसे संदर्भ बाध्य किया गया है या अस्थायी है जो एक उप-विषय के लिए पूरी वस्तु है जिसमें अस्थायी बाध्य है संदर्भ के जीवनकाल के लिए नीचे निर्दिष्ट के अलावा बनी रहती है। एक कंस्ट्रक्टर के ctor-initializer (12.6.2) में एक संदर्भ सदस्य के लिए एक अस्थायी बाध्य, जब तक कि कंस्ट्रक्टर बाहर नहीं निकलता है। फ़ंक्शन कॉल (5.2.2) में संदर्भ पैरामीटर के लिए एक अस्थायी बाध्य कॉल को पूर्ण अभिव्यक्ति के पूरा होने तक बनी रहती है।

लेख के लेखन के दौरान, मैं एच। सैटर http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/ द्वारा एक लेख भर आया।
साथ ही एक दिलचस्प उदाहरण http://www.rsdn.ru/forum/cpp/4257549.flat

 #include <iostream> struct foo { ~foo() { std::cout << "~foo()\n"; } }; struct foo_holder { const foo &f; }; int main() { foo_holder holder = { foo() }; std::cout << "done!\n"; return 0; } 

मेरा सुझाव है कि निष्कर्ष होना चाहिए

 ~foo() done! 

क्योंकि इस मामले में, अस्थायी ऑब्जेक्ट का उपयोग अभिव्यक्ति में किया जाता है, जो कि इनिशलाइज़र है, और फिर, जैसे कि सामान्य कार्यों के मामले में, अस्थायी ऑब्जेक्ट का जीवनकाल अभिव्यक्ति की तुलना में अधिक लंबा नहीं होता है।
लेकिन व्यवहार में, परिणाम थोड़ा अलग है।
आउटपुट (msvs 2012):

 ~foo() done! ~foo() 

और (g ++ (Ubuntu / Linaro 4.7.3-1ubuntu1) 4.7.3):

 done! ~foo() 

आपका ध्यान देने के लिए धन्यवाद, आपका दिन शुभ हो।