😤 👍🏼 📕 रहस्य ऑटो और घोषणा 👨🏻‍💼 🌅 ☝🏽

नया भाषा मानक अपेक्षाकृत पहले और अब अपनाया गया है, शायद, ऐसा कोई प्रोग्रामर नहीं है जिसने नए कीवर्ड्स ऑटो और घोषणापत्र के बारे में नहीं सुना है। लेकिन C ++ के लगभग हर पहलू के साथ, इन नए उपकरणों का उपयोग इसकी बारीकियों के बिना नहीं है। मैं इस लेख में उनमें से कुछ को उजागर करने का प्रयास करूंगा।

वार्म अप करने के लिए, मैं सुझाव देता हूं कि एक छोटे परीक्षण से शुरू करें।

कसौटी

1. निम्न कोड निष्पादित करने के बाद ri1..riN चर किस प्रकार का होगा?

int foo(); int& foo1(); const int foo2(); const int& foo3(); int main() { auto ri = foo(); auto ri1 = foo1(); auto ri2 = foo2(); auto ri3 = foo3(); auto& ri4 = foo(); auto& ri5 = foo1(); auto& ri6 = foo2(); auto& ri7 = foo3(); auto&& ri8 = foo(); auto&& ri9 = foo1(); auto&& ri10 = foo2(); auto&& ri11 = foo3(); int k = 5; decltype(k)&& rk = k; decltype(foo())&& ri12 = foo(); decltype(foo1())&& ri13 = foo1(); int i = 3; decltype(i) ri14; decltype((i)) ri15; }

निम्नलिखित स्निपेट संकलन करेंगे?

 2. auto lmbd = [](auto i){...}; 3. void foo(auto i); 4. decltype(auto) var = some_expression; //WTF?! 5. auto var = {1, 2, 3}; // ,     var? 6. template<typename T> void foo(T t){} foo({1, 2, 3});

सिद्धांत

C ++ 11: ऑटो और डिक्लेपट में टेम्प्लेट में उपयोग किए जाने वाले प्रकार के इन्वेंशन तंत्र में दो नए तंत्र जोड़े गए हैं। और इसलिए कि जीवन के लिए प्रोग्रामरों को शहद नहीं लगता है, ये सभी 3 तंत्र अपने तरीके से टाइप करते हैं। ऑटो द्वारा उपयोग किया जाने वाला तंत्र खाका इंजन की प्रतिलिपि बनाता है, प्रकार std :: initializer_list को छोड़कर।

 auto var = {1, 2, 3}; // Ok, var    std::initializer_list<int> template<typename T> void foo(T t); foo({1, 2, 3}); //

इस तरह के व्यवहार के लिए कुछ स्पष्टीकरण हैं और वे सभी समझदारी में भिन्न नहीं हैं। उदाहरण के लिए, स्कॉट मेयर्स, इस विषय पर लिखते हैं: “मुझे नहीं पता कि ऑटो के लिए और टेम्पलेट्स के लिए कटौती क्यों समान नहीं है। यदि आप जानते हैं, तो कृपया मुझे बताएं! ” । C ++ 14 में, यह तंत्र बदलने वाला नहीं है। स्पष्टीकरण के लिए, कोई भी इस तथ्य को ले सकता है कि ऐसी अद्भुत चीजें काम करती हैं, उदाहरण के लिए:

 template<typename T> void fill_from_list(T& cont, const T& l); std::vector<int> v; fill_from_list(v, {1, 2, 3});

ऑटो

तो `ऑटो` एक प्रकार कैसे घटाता है? दुर्भाग्य से, सभी अवसरों के लिए कोई सरल नियम नहीं है, सिवाय, शायद, कि `ऑटो` जब टाइप करते हैं तो आमतौर पर सीवी क्वालीफायर और लिंक को छोड़ते हैं। नीचे मैं सबसे महत्वपूर्ण बिंदुओं की सूची दूंगा।

1।

 auto var = some_expression;

यदि टाइप some_expression T * या const T * है , तो टाइप var क्रमशः T * या const T * भी होगा। अब तक कोई आश्चर्य नहीं हुआ। अधिक दिलचस्प है। व्यावहारिक दृष्टिकोण से शायद सबसे महत्वपूर्ण नियम यह है कि अगर some_expression का प्रकार T , const T , T & const या const T है , तो var का प्रकार T है। हालाँकि, यदि आप इसके बारे में सोचते हैं, तो यह काफी तार्किक है, क्योंकि इस मामले में some_expression द्वारा लौटाए गए मान को var पर कॉपी किया जाता है और आप सुरक्षित रूप से इस तरह लिख सकते हैं:

 void foo(const std::list<widget_t>& l) { auto w = l.front(); l.pop(); // work with `w` here }

2।

 auto& var = some_expression;

इस मामले में, यह उम्मीद की जाती है कि यदि टाइप some_expression T या const T है , तो यह संकलन नहीं करेगा, क्योंकि lvalue लिंक को rvalue के साथ आरंभ नहीं किया जा सकता है। यदि some_expression का प्रकार T & है , तो var भी T & प्रकार का होगा। यहाँ महत्वपूर्ण बिंदु यह है कि अगर some_expression का प्रकार const T & है , तो var का प्रकार const T & होगा ।

3।

 auto&& var = some_expression;

स्कॉट मेयर्स द्वारा लागू (या कम से कम आवाज द्वारा) "सार्वभौमिक लिंक" का नियम यहां लागू होता है। यह इस तथ्य में सम्‍मिलित है कि प्रकार var कुछ श्रेणी के मान पर निर्भर करेगा जो some_expression है । यदि rvalue है , तो प्रकार var T && होगा , यदि lvalue , तो T && । Cv क्वालिफायर सहेजे जाते हैं।

फ़ंक्शन पैरामीटर के रूप में ऑटो

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

 auto foo(auto v1, auto v2) -> decltype(v1+v2) ; int foo(auto v1, bool v2); foo(“C++ is cool?”, true);

हालांकि, c ++ 14 में लैम्ब्डा में ऑटो मापदंडों का उपयोग करना संभव होगा।

decltype

घोषणापत्र के साथ , एक तरफ स्थिति अधिक जटिल होती है (यदि आप औपचारिक नियमों को देखें), दूसरी तरफ यह आसान है (यदि आप मुख्य बिंदुओं को उजागर करते हैं)। मैं इन नियमों को तैयार करूंगा क्योंकि मैंने उन्हें समझा था।
इसलिए, हमें डिक्लेरेशन के दो मुख्य मामलों में अंतर करना चाहिए।
1. जब एक घोषित चर (उदाहरण के लिए, एक फ़ंक्शन में या एक वर्ग के सदस्य के रूप में ) डिक्लेपट (संस्करण )। इस स्थिति में, डिक्वेस्ट (var) में वैसा ही प्रकार होगा जिसके साथ वैरिएबल घोषित किया गया है।
2. घोषणा (expr) , expr एक अभिव्यक्ति है। इस स्थिति में, घोषणापत्र (expr) वह प्रकार होगा, जिससे यह अभिव्यक्ति वापस आ सकती है , साथ ही प्रोविटाइप (expr) टाइप T & ( const T & ) का होगा, अगर expr एक लैवल्यू लौटाता है, T यदि rr टाइप T का रिटर्न देता है ( यदि टीआरपी एक्सएंडटी ( टीएंडसीपी ) और टीएंडसी ( कास्ट टीएंडसी ) एक्सफ्लू ( रेवल्यू रेफरेंस ) देता है।

"वापसी" का क्या मतलब है? इसका मतलब यह है कि डिक्लेप्ट यह तर्क के रूप में उसके पास गई अभिव्यक्ति का मूल्यांकन नहीं करता है।
कुछ उदाहरण हैं:

 int i; decltype(i); // int decltype(i + 1); // int decltype((i)); // int& decltype(i = 4); //int& const int foo(); decltype(foo()) ;// int int&& foo1(); decltype(foo1()) ;// int&&

इस घटना में कि हम लवल्यू को नहीं जानते हैं , एक अभिव्यक्ति, रवैल्यू या ज़वल्यू हमें लौटा देगा, और हम टाइप का उपयोग करना चाहते हैं, आप लिंक के प्रकार को "स्पष्ट" करने के लिए मानक std :: remove_reference टेम्पलेट का उपयोग कर सकते हैं।

डिक्रिप्ट (ऑटो)

यह भाषा का एक नया "फीचर" है, जिसे C ++ 14 में शामिल किया जाएगा। ऑटो वैरिएबल की घोषणा करते समय घोषित शब्दार्थों को संरक्षित करने की आवश्यकता है और उन मामलों में उपयोग किया जाएगा जहां हम इस तथ्य से संतुष्ट नहीं हैं कि ऑटो लिंक और cv क्वालीफायर और संभवत: नए C ++ 14 फीचर के संयोजन में फ़ंक्शन द्वारा लौटाए गए मान के प्रकार को आउटपुट करते हैं। ।

 const int&& foo(); auto i = foo(); // i    int dectype(auto) i2 = foo(); // i2    const int&&

उत्तरार्द्ध मामले में, हम डिक्टाइप (फू) () लिख सकते हैं, लेकिन कल्पना करें कि अगर फू () के बजाय 2 लाइनों के साथ एक अभिव्यक्ति थी, और ऐसे सी + + में असामान्य नहीं हैं।

उत्तर

खैर, अब, सिद्धांत को कैश में लोड करने के बाद, आप परीक्षण प्रश्नों का उत्तर देने का प्रयास कर सकते हैं।

1।

 int foo(); int& foo1(); const int foo2(); const int& foo3(); int main() { auto ri = foo(); // int auto ri1 = foo1(); // int auto ri2 = foo2(); // int auto ri3 = foo3(); // int auto& ri4 = foo(); //   auto& ri5 = foo1(); // int& auto& ri6 = foo2(); //   auto& ri7 = foo3(); // const int& auto&& ri8 = foo(); // int&& auto&& ri9 = foo1(); // int& auto&& ri10 = foo2(); // const int&& auto&& ri11 = foo3(); // const int& int k = 5; decltype(k)&& rk = k; //   decltype(foo())&& ri12 = foo(); // int&& decltype(foo1())&& ri13 = foo1(); // int& int i = 3; decltype(i) ri14; // int decltype((i)) ri15; // int& }