सदस्य कन्स्ट्रक्टर और विनाशक का आदेश

Question

ओह सी ++ गुरु, मैं आपकी बुद्धि की तलाश करता हूं। मेरे लिए standardese बोलते हैं और मेरे अगर सी ++ की गारंटी देता है बताते हैं कि निम्नलिखित कार्यक्रम:

#include <iostream> 
using namespace std; 

struct A 
{ 
    A() { cout << "A::A" << endl; } 
    ~A() { cout << "A::~" << endl; } 
}; 

struct B 
{ 
    B() { cout << "B::B" << endl; } 
    ~B() { cout << "B::~" << endl; } 
}; 

struct C 
{ 
    C() { cout << "C::C" << endl; } 
    ~C() { cout << "C::~" << endl; } 
}; 

struct Aggregate 
{ 
    A a; 
    B b; 
    C c; 
}; 

int main() 
{ 
    Aggregate a; 
    return 0; 
} 

हमेशा

A::A 
B::B 
C::C 
C::~ 
B::~ 
A::~ 

दूसरे शब्दों में उत्पादन करेगा, सदस्यों घोषणा के आदेश से प्रारंभ और रिवर्स में नष्ट हो जाने की गारंटी है आदेश?

Answer 1

दूसरे शब्दों में, सदस्यों को घोषणा के क्रम में आरंभ करने और रिवर्स ऑर्डर में नष्ट करने की गारंटी दी जाती है?

दोनों के लिए हाँ। देखें 12.6.2

प्रारंभ आदेश निम्नलिखित में आगे बढ़ना होगा: के रूप में, आभासी आधार नीचे वर्णित

• पहले, और केवल सबसे व्युत्पन्न वर्ग के निर्माता के लिए कक्षा क्रम में शुरू की जाएगी, वे के बाएं-से-दाएं ट्रैवर्सल पर दिखाई देते हैं, जो आधारके निर्देशित ग्राफ़िक ग्राफ़ पर प्रदर्शित होते हैं। 0 वर्ग, जहां "बाएं से दाएं" बेस क्लास व्युत्पन्न कक्षा आधार-विनिर्देश-सूची में नामों के क्रम का क्रम है।

• फिर, प्रत्यक्ष आधार वर्ग घोषणा के क्रम में प्रारंभ किया जाएगा के रूप में वे में ( मेम-initializers के आदेश की परवाह किए बिना) आधार विनिर्देशक-सूची दिखाई।

• फिर, गैर स्थिर डेटा सदस्यों क्रम में वे वर्ग परिभाषा में घोषित थे में प्रारंभ किया जाएगा (फिर मेम-initializers के आदेश की परवाह किए बिना)।

• अंत में, निर्माता शरीर के यौगिक बयान निष्पादित किया जाता है। [नोट: घोषणा आदेश को अनिवार्य है कि आधार और सदस्य उप-प्रोजेक्ट प्रारंभिक क्रम के विपरीत क्रम में नष्ट हो गए हैं। अंत टिप्पणी]

Answer 2

हाँ और हाँ। विनाश का आदेश सदस्य चर के लिए, निर्माण के आदेश के विपरीत हमेशा विपरीत होता है।

Answer 3

हां, वे (गैर स्थैतिक सदस्य हैं) हैं। प्रारंभिकरण (निर्माण) के लिए 12.6.2/5 और विनाश के लिए 12.4/6 देखें।

Answer 4

हाँ, मानक की गारंटी देता है वस्तुओं उलटे क्रम वे बनाए गए थे में विलुप्त हो जाते हैं। कारण यह है कि एक वस्तु दूसरे का उपयोग कर सकती है, इस प्रकार इस पर निर्भर करती है।पर विचार करें: संहार करने से पहले b तो b गलत सदस्य संदर्भ पकड़ थे

struct A { }; 

struct B { 
A &a; 
B(A& a) : a(a) { } 
}; 

int main() { 
    A a; 
    B b(a); 
} 

a हैं। ऑब्जेक्ट्स को रिवर्स ऑर्डर में नष्ट करके जिसमें वे बनाए गए थे, हम सही विनाश की गारंटी देते हैं।