निर्माता कॉल पदानुक्रम

Question

मैं एक प्रकार पदानुक्रम में निर्माताओं के लिए नियमों बुला के साथ एक मुश्किल समय हो रही है। (

class A{ 
protected: 
    int _i; 
public: 
    A(){i = 0;} 
    A(int i) : _i(i){} 
    virtual ~A(){} 
    virtual void print(){std::cout<<i<<std::endl;} 
}; 

class B : virtual public A{ 
protected: 
    int _j; 
public: 
    B() : A(){_j = 0;} 
    B(int i, int j) : A(i), _j(j){} 
    virtual ~B(){} 
    virtual void print(){std::cout<<i<<", "<<j<<std::endl;} 
}; 

class C : virtual public B{ 
protected: 
    int _k; 
public: 
    C() : B(){_k = 0;} 
    C(int i, int j, int k} : B(i,j), _k(k){} 
    virtual ~C(){} 
    virtual void print(){std::cout<<i<<", "<<j<<", "<<k<<std::endl;} 
}; 

int main(){ 
    C* myC = new C(1,2,3); 
    myC->print(); 
    delete myC; 
    return 0; 
} 

अब, मैं नई सी (1,2,3) बी (1,2) के निर्माता फोन जो तब बदले में निर्माता एक फोन करना चाहिए करना चाहते हैं 1: यहाँ मैं क्या कर रहा है) _i = 1, _j = 2, _k = 3 स्टोर करने के लिए। कक्षा सी के उदाहरण आईसी बनाते समय, किसी कारण से मुझे समझ में नहीं आता है, हालांकि, पहले कन्स्ट्रक्टर को कॉल करने के लिए मानक कन्स्ट्रक्टर ए, यानी ए :: ए(); यह स्पष्ट रूप से गलत परिणाम की ओर जाता है, क्योंकि संरक्षित चर _i को मान 0 असाइन किया गया है। कन्स्ट्रक्टर ए (1) कभी नहीं कहा जाता है। ऐसा क्यों है? मुझे यह बहुत काउंटर अंतर्ज्ञानी लगता है। वांछित व्यवहार प्राप्त करने के लिए टाइप-पदानुक्रम के भीतर सभी रचनाकारों को स्पष्ट रूप से कॉल करने से बचने का कोई तरीका है?

सहायता के लिए Thx!

Answer 1

जब आप आभासी विरासत का उपयोग करें, सबसे व्युत्पन्न वर्ग अपने सभी आभासी सीधे अड्डों के लिए कंस्ट्रक्टर कॉल करना होगा। इस मामले में, C के लिए निर्माता को B और A के लिए निर्माता को कॉल करना होगा। चूंकि आप केवल B कन्स्ट्रक्टर को कॉल करते हैं, यह डिफ़ॉल्ट A कन्स्ट्रक्टर का उपयोग करता है। इससे कोई फर्क नहीं पड़ता कि B कन्स्ट्रक्टर अन्य A कन्स्ट्रक्टर कहता है: चूंकि यह वर्चुअल बेस क्लास है, इसलिए इस कॉल को अनदेखा किया जाता है। स्पष्ट रूप से A(int) निर्माता फोन:

आप इस समस्या को हल दो तरीके हैं

C(int i, int j, int k} : A (i), B(i,j), _k(k){} 

या आभासी के बजाय सामान्य विरासत का उपयोग करें।

Answer 2

इसका कारण यह है कि आप आभासी विरासत, जो कई विरासत की उपस्थिति में ही समझ में आता है इस्तेमाल किया। बस सामान्य रूप से वारिस करें, और जैसा कि आप उम्मीद करेंगे उतना ही होगा।

Answer 3

तुम सच में यहाँ एक virtual विरासत की ज़रूरत है? आप एक समस्या मिल गया है क्योंकि एक बहुत पहले आभासी आधार ctor पहले बुलाया जाएगा, लेकिन जब B से C वारिस आप किसी भी निर्दिष्ट नहीं करते हैं (उत्तरार्द्ध पहले से ही A, लेकिन लगभग विरासत में मिला है, इसलिए डिफ़ॉल्ट कहा जाता था)।

एक समाधान के रूप में आर्नी Mertz के जवाब में बताया गया आभासी विरासत को दूर करने के ... है। एक और (यदि आप वास्तव में आभासी विरासत चाहते हैं) C ctor से स्पष्ट रूप से A कॉल करने के लिए है:

C(int i, int j, int k} : A(i), B(i,j), _k(k){} 

Answer 4

आप वर्चुअल विरासत क्यों घोषित करते हैं? यदि आप कक्षा बी से वर्चुअल कीवर्ड हटाते हैं: वर्चुअल पब्लिक ए {... तो आपका कोड ठीक काम करेगा। आभासी ए घोषित करके, सी सीधे ए() को कॉल करेगा। यदि आप वर्चुअल को हटाते हैं तो सी ए() को कॉल नहीं करेगा।