शुभ दोपहर, प्रिय पाठक!

यह लेख अमूर्त लेखों की एक श्रृंखला में पहला है जिसे मैं स्कॉट मेयर्स की पुस्तक, इफेक्टिव और मॉडर्न c ++ के माध्यम से पढ़ूंगा। इन लेखों में से प्रत्येक में विशेष रूप से github.com पर वर्णित परियोजना में एक अलग निर्देशिका होगी जिसमें वर्णित विशेषताओं और तकनीकों का उपयोग किया जाएगा।

खाका प्रकार आविष्कार

सफल डिजाइन तब होता है जब उपभोक्ता को यह नहीं पता होता है कि उपकरण कैसे काम करता है, लेकिन सब कुछ उसके अनुरूप है।

टेम्पलेट प्रकार का निष्कर्ष तब होता है जब कोई टेम्पलेट फ़ंक्शन होता है, उदाहरण के लिए, और इसे बिना किसी टेम्पलेट और कोण कोष्ठक के कहा जाता है। इस मामले में, संकलक अनुमान लगाता है कि फ़ंक्शन के किसी विशेष ऑब्जेक्ट में इसका उपयोग करने के लिए किस प्रकार की आवश्यकता होगी।

मेयर्स प्रकार - "टी" को विभाजित करता है, जो प्रदर्शित होता है और प्रकार - "पैरामैप्टाइप" , जो प्रोग्रामर द्वारा पैरामीटर की परिभाषा में निर्धारित किया जाता है।

1. पैरामीटर दृश्य - लिंक या पॉइंटर

व्युत्पन्न नियम को जल्दी से समझने के लिए, मैं इसे एक टेम्पलेट के रूप में प्रतिबिंबित करूंगा:

इनपुट प्रकार -> प्रकार, पैरामीटर -> आउटपुट प्रकार [, अंतिम प्रकार का पैरामीटर ]

एक लिंक के साथ उदाहरण:

template<typename T> //   T void func(T& param) //   - T& int x = 0; //   int func(x); 

टाइप टी के मामले में , संदर्भ (*, और) को छोड़ दिया जाता है क्योंकि यह फ़ंक्शन को परिभाषित करते समय पहले से ही संकेत दिया जाता है, जैसे कि इसका मतलब है "आप वहां कुछ भी पास करते हैं, हम मान लेंगे कि यह लिंक नहीं है, क्योंकि संदर्भ पहले से ही खपत के स्थान पर जोड़ा गया है - हमारे समारोह में एफ "

यदि फ़ंक्शन पैरामीटर में निर्दिष्ट किया गया है, तो उसी सिद्धांत द्वारा, कब्ज को छोड़ दिया जाता है। लिंक, पॉइंटर्स, कॉन्स्टेंसी पर, जैसा कि यह था, एक विशेष मुखौटा लगाया जाता है।

निकासी योजना

 //   int —> (T & param) —> int; const int —> (T & param) —> const int; const int & —> (T & param) —> const int //   int —> (const T & param) —> int; const int —> (const T & param) —> int; const int & —> (const T & param) —> int; //   int * —> (T * param) —> int; const int —> (T * param) —> const int; const int * —> (T * param) —> const int; //   int * —> (const T * param) —> int; const int —> (const T * param) —> int; const int * —> (const T * param) —> int; 

2. तर्क का प्रकार - सार्वभौमिक संदर्भ

स्कॉट ने उल्लेख किया है कि सार्वभौमिक लिंक पर बाद में विचार किया जाएगा, इसलिए मापदंडों के लिए नियम जो वह यहां रैलिंग और लैवल्यू में विभाजित करता है, बस थोड़ा विचार के साथ याद रखने की आवश्यकता है।

 template<typename T> void func(const T&& param) 

बचाव के लिए नियम

यह, स्कॉट का दावा है, एकमात्र ऐसा मामला है जहां टी एक संदर्भ के रूप में आउटपुट है।
निम्नलिखित उदाहरणों में, फ़ंक्शन विवरण में पैरामीटर का प्रकार एक सार्वभौमिक लैवल्यू संदर्भ है । यह देखा जा सकता है कि टी को एक लिंक या एक स्थिर लिंक के रूप में प्रदर्शित किया जाता है, यह निर्भर करता है
इनपुट तर्क से, परम पैरामीटर का प्रकार भी इस मामले में एक संदर्भ है।

 lvalue int —> (T &&param) —> int &, param - int& lvalue const int —> (T &&param) —> const int &, param - const int& lvalue const int & —> (T &&param) —> const int &, param - const int& 

पैरामीटर के प्रकार को भी बदल दिया जाता है। मुझे लगता है कि यह इस तथ्य के कारण है कि भाषा कहीं ऊपर आवंटित एक लैवल्यू-वैरिएबल पर विचार नहीं कर सकती है, जिसे आगे ले जाया जा सकता है। जब हम सार्वभौमिक लिंक प्राप्त करेंगे तो हम बाद में इसका पता लगाएंगे।
यह सत्यापित करने के लिए कि T वास्तव में एक संदर्भ प्रकार है, मैंने टेम्पलेट फ़ंक्शन के शरीर में T myVar लिखा, जिसे इस टी ने दोनों को प्रदर्शित किया और अपेक्षित रूप से एक संदेश प्राप्त किया - "संदर्भ के रूप में घोषित नहीं किया गया है" - लिंक :)

बचाव के लिए नियम

अनुच्छेद 1 के "सामान्य" नियम लागू होते हैं।

 rvalue int —> (T &&param) —> int, param - int&& 

यह पहले से ही स्पष्ट है कि सार्वभौमिक संदर्भ केवल "शामिल" हैं, केवल रैलू-अस्थायी वस्तुओं के लिए, अन्य मामलों में, जब तर्क एक सार्वभौमिक संदर्भ नहीं है, तो प्रतिद्वंद्विता, लैवल्यू प्रतिष्ठित नहीं है

3. मान से पास करें (जैसा है)

जब मूल्य से गुजरते हैं, तो मूल तर्क की स्थिरता और संदर्भहीनता को अनावश्यक रूप से खारिज कर दिया जाता है क्योंकि ये पूरी तरह से नई स्वतंत्र वस्तुएं हैं, तो उन्हें उन योग्यताओं की आवश्यकता क्यों है जिनके साथ वे जुड़े नहीं हैं?

 int —> (T param) —> int const int —> (T param) —> int const int & —> (T param) —> int //       ,     const char * const —> (T param) —> const char * 

मुझे लगता है कि अन्य पागल और अतार्किक संयोजन संकलन त्रुटियों का कारण होगा, लगभग हमेशा, यह पता चला है, संकलक का काम समझ में आता है, आपको केवल एक बार इन स्पष्टीकरणों को सुनने की आवश्यकता है।