🌃 🤶 🎩 विस्तार से स्पष्ट ℹ️ ➕ 👹

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

class Simple { public: Simple(int a) : a_(a) {} private: int a_; }; class SimpleExplicit { public: explicit SimpleExplicit(int a) : a_(a) {} private: int a_; }; template <typename S> void someFunc(const S& s) { } int main(int, char**) { Simple s3 = 11; // SimpleExplicit se3 = 11; - COMPILE ERROR SimpleExplicit se3 = SimpleExplicit(11); someFunc<Simple>(11); // someFunc<SimpleExplicit>(11); - COMPILE ERROR someFunc<SimpleExplicit>(SimpleExplicit(11)); return 0; }

अच्छे पुराने C ++ 03 में, कीवर्ड एप्लिकेशन परिदृश्य वहां समाप्त हो गए, हालांकि, C ++ 11 के साथ शुरू, स्पष्ट विस्तार की गुंजाइश: अब यह न केवल एक पैरामीटर के साथ कंस्ट्रक्टरों में, और यहां तक कि न केवल कंस्ट्रक्टरों में भी समझ में आता है।

2011 में, स्टैंडर्ड को यूनिवर्सल इनिशियलाइज़ेशन जोड़ा गया था, जो कि C से विरासत में मिली चीज़ों को इनिशियलाइज़ करने के चिड़ियाघर के तरीकों को सी से साफ़ कर देना चाहिए। मैं यहाँ यूनिवर्सल इनिशियलाइज़ेशन के बारे में विस्तार से बात नहीं करूँगा, इस विषय पर कई विस्तृत लेख हैं, उनके कीवर्ड द्वारा खोजना आसान है। संक्षेप में: वस्तुओं को घुंघराले ब्रेसिज़ का उपयोग करके आरंभ करने का प्रस्ताव है, वास्तव में यह विस्तार तथाकथित है सी से विरासत में मिली कुल आरंभ।

सार्वभौमिक आरंभ के आगमन के साथ, 0.2.3 या अधिक मापदंडों के साथ डिजाइनरों के लिए स्पष्ट रूप से समझ में आया:

 class Simple { public: Simple() : a_(0), b_(0) {} Simple(int a) : a_(a), b_(0) {} Simple(int a, int b) : a_(a), b_(b) {} private: int a_, b_; }; class SimpleExplicit { public: explicit SimpleExplicit() : a_(0), b_(0) {} explicit SimpleExplicit(int a) : a_(a), b_(0) {} explicit SimpleExplicit(int a, int b) : a_(a), b_(b) {} private: int a_, b_; }; template <typename S> void someFunc(const S& s) { } int main(int, char**) { Simple s4 = {}; someFunc<Simple>({}); // SimpleExplicit se4 = {}; - COMPILE ERROR SimpleExplicit se4 = SimpleExplicit{}; // someFunc<SimpleExplicit>({}); - COMPILE ERROR someFunc<SimpleExplicit>(SimpleExplicit{}); Simple s5 = {11}; someFunc<Simple>({11}); // SimpleExplicit se5 = {11}; - COMPILE ERROR SimpleExplicit se5 = SimpleExplicit{11}; // someFunc<SimpleExplicit>({11}); - COMPILE ERROR someFunc<SimpleExplicit>(SimpleExplicit{11}); Simple s6 = {11, 22}; someFunc<Simple>({11, 22}); // SimpleExplicit se6 = {11, 22}; - COMPILE ERROR SimpleExplicit se6 = SimpleExplicit{11, 22}; // someFunc<SimpleExplicit>({11, 22}); - COMPILE ERROR someFunc<SimpleExplicit>(SimpleExplicit{11, 22}); return 0; }

इसके अलावा, C ++ 11 से शुरू होकर, स्पष्ट कीवर्ड को रूपांतरण ऑपरेटरों पर भी लागू किया जा सकता है, साथ ही उनके अंतर्निहित आह्वान को भी रोक सकता है:

 class Simple { public: Simple() {} operator bool() const { return true; } }; class SimpleExplicit { public: explicit SimpleExplicit() {} explicit operator bool() const { return true; } }; int main(int, char**) { Simple s7{}; bool b7 = s7; SimpleExplicit se7{}; // bool be7 = se7; - COMPILE ERROR bool be7 = static_cast<bool>(se7); return 0; }

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

विस्तार से स्पष्ट

More articles: