डिफ़ॉल्ट कन्स्ट्रक्टर

Question

के साथ ऑब्जेक्ट्स के लिए प्रारंभकर्ता सूची क्या किसी प्रारंभिक सूची में क्लास सदस्य चर डालने का कोई लाभ है जिसे प्रारंभकर्ता सूची में होने की आवश्यकता नहीं है? उदाहरण:

class Foo 
{ 
public: 
    Foo() {} 
}; 

class Bar 
{ 
public: 
    Bar() : _foo() {} 

private: 
    Foo _foo; 
}; 

क्या इस मामले में संकलक कुछ खास करता है?

Answer 1

एक प्रारंभकर्ता सूची में एक निर्माता को प्रारंभ करने का पसंदीदा तरीका है। संदर्भ सदस्यों और निरंतर सदस्यों को प्रारंभ करने का यह एकमात्र संभव तरीका है।

इसके अलावा प्रारंभकर्ता सूची का उपयोग करके, प्रारंभ होने से पहले गलती से चर का उपयोग करने की संभावना को कम करता है। यह के बड़े दर्शन का हिस्सा है जो इसे प्रारंभ किए बिना एक चर परिभाषित करता है।

Answer 2

नहीं, इस मामले में कुछ भी अलग नहीं किया गया है। मुझे ऐसा करने का कोई फायदा नहीं दिख रहा है।

Answer 3

जिन सदस्यों का उपयोग किया जा रहा है, कन्स्ट्रक्टर की प्रारंभकर्ता सूची में उल्लिखित सदस्य डिफ़ॉल्ट-प्रारंभिक नहीं हैं। Foo के लिए इसका मतलब है कि डिफ़ॉल्ट कन्स्ट्रक्टर को बुलाया जाएगा।

Bar() : _foo() { } और बिल्कुल नहीं Bar दे रही है एक स्पष्ट डिफ़ॉल्ट निर्माता (या Bar() = default कह रही है कि अपने संस्करण एक छोटी सी डिफ़ॉल्ट निर्माता नहीं है। इस प्रकार std::is_trivially_constructible<Bar>::value के मूल्यों यदि आप निर्माण ­ टो बाएं से अलग होगा के बीच का अंतर कुल मिलाकर बाहर है, हालांकि व्यवहार अन्यथा एक ही है।

Answer 4

इस मामले में यह कोई फर्क नहीं पड़ता।

लेकिन यह ऐसा करने के लिए उपयोगी हो सकता है।
आप सदस्यों की एक बड़ी संख्या फिर कुछ लेकिन होने है, तो सूची में सभी सदस्य नहीं कर सकते हैं कुछ भ्रम का कारण बनता है। इसके अलावा यह आपके दिमाग में प्रारंभिकरण के क्रम को मजबूत करता है (आदेश कक्षा में घोषणा के क्रम द्वारा परिभाषित किया जाता है, लेकिन यह बड़े वर्गों में इस आदेश को देखने के लिए उपयोगी हो सकता है जहां सभी सदस्य चर एक दूसरे के बगल में घोषित नहीं होते हैं)।

नोट: यदि आप उन्हें आंतरिककरण सूची में गलत क्रम में डालते हैं तो यह आमतौर पर अधिकांश कंपाइलरों पर एक चेतावनी है (जब तक आप चेतावनियों को त्रुटियों के रूप में संकलित नहीं करते हैं (जो आपको करना चाहिए)।

असली खतरा कक्षाओं के साथ है जिसमें पीओडी सदस्य और कंपाइलर उत्पन्न कन्स्ट्रक्टर है।

class NewFoo 
{ 
     int x; 
     int y; 
}; 
// Version 1: 
class Bar1 
{ 
    NewFoo f; 
}; 
// Version 2: 
class Bar2 
{ 
    NewFoo f; 
    public: 
     Bar2() // f not in list. 
     {} 
}; 
// Version 3: 
class Bar3 
{ 
    NewFoo f; 
    public: 
     Bar3() 
      : f() 
     {} 
}; 

int main() 
{ 
    Bar1  b1a;   // x and y not initialized. 
    Bar1  b1b = Bar1(); // x and y zero initialized. 
    Bar2  b2a;   // x and y not initialized. 
    Bar2  b2b = Bar2(); // x and y not initialized. 
    Bar3  b3a;   // x and y zero initialized. 
    Bar3  b3b = Bar3(); // x and y zero initialized. 
}