सी ++/सीएलआई

Question

में किसी अन्य कन्स्ट्रक्टर को अधिभारित कन्स्ट्रक्टर कॉल को अग्रेषित करने के लिए कैसे करें मुझे पता है कि pure C++ में ऐसा करने का कोई तरीका नहीं है, लेकिन मैं सोच रहा था कि सी ++/सीएलआई में किसी अन्य निर्माता की प्रारंभिक सूची से निर्माता को कॉल करना संभव है या नहीं , वैसे ही कोई इसे सी # में कर सकता है।

उदाहरण:

ref class Foo { 
    Foo() {} 
    Foo(int i) : Foo() {} 
} 

Answer 1

यह एक "सौंपने के निर्माता" कहा जाता है। यह अभी तक भाषा में उपलब्ध नहीं है। लेकिन एक औपचारिक प्रस्ताव है, आप इसे language specification के अनुबंध F.3.1 में पाएंगे। सी ++/सीएलआई की ओर माइक्रोसॉफ्ट के रुख को देखते हुए, यह जल्द ही दिन की रोशनी को देखने की संभावना नहीं है।

---

अद्यतन: सौंपने के कंस्ट्रक्टर्स कि उपभवन में प्रस्ताव से परे एक जीवन था, वे मानक सी ++ 11 भाषा विनिर्देश में जोड़ा गया। माइक्रोसॉफ्ट सी ++ 11 परिवर्धन लागू करने पर काम कर रहा है। प्रतिनिधियों ने अंततः वीएस2013 के लिए इसे बनाया। और वे उस संस्करण में सी ++/सीएलआई में भी काम करते हैं।

Answer 2

आप निम्न

ref class A 
{ 
public: 
    A(int p) : p(p) { this->A::A(); } 
    A() : p(1) {} 

    int p; 
}; 

यह वैध सी ++ कोड नहीं है, लेकिन कुलपति यह ठीक संकलित :) क्या कर सकते हैं

Answer 3

जब आप ने कहा "मुझे पता है में यह करने के लिए कोई रास्ता नहीं है कि वहाँ शुद्ध सी ++ " आप त्रुटि में थे। देशी सी ++ में ऐसा करना संभव है। ऐसा करने के लिए आप प्लेसमेंट नए ऑपरेटर का उपयोग कर सकते हैं।

class A 
{ 

public: 

    A(int p) : p(p) 
    { new(this)A(); } 

    A() : p(1) {}  

    int p; 
}; 

Answer 4

बस एक ही प्रश्न के लिए, ठोकर खाई। मेरे मामले में मैं वीएस -2010 का उपयोग कर रहा हूं।

यह स्पष्ट है कि VS2010 कभी भी C++ 11 को लागू करने के लिए अपडेट नहीं किया जाएगा, यदि आपको मानक के साथ बेहतर अनुपालन की आवश्यकता है (जो मैं कर सकता हूं) तो VS2015 का उपयोग करें। लेकिन कुछ (विरासत) परियोजनाओं के लिए मुझे अभी भी वीएस -2010 का उपयोग करना है।

कई मामलों में (मेरे लिए) एक दृष्टिकोण जो एक निजी समारोह का उपयोग करता है जिसमें सभी साझा प्रारंभिक कोड कोड होते हैं। उदाहरण:

class A 
{ 
private: 
    void Inidialise() { /* common initialisation here */ } 

public: 
    A()  { Initialise(); /* specific initialisation for A() here */ } 
    A(bool a) { Initialise(); /* specific initialisation for A(bool) here */ } 
    A(int b) { Initialise(); /* specific initialisation for A(int) here */ } 

    /* etcetera */ 

} 

यह सब 'समस्याओं' का समाधान नहीं करता है और यह दोहरे कोड के सभी मामलों को नहीं रोकता है, लेकिन यह एक लंबा रास्ता जाता है।