C ++ 11 या T && में "यूनिवर्सल" संदर्भ का हमेशा मतलब नहीं होता है "संदर्भ संदर्भ"

बहुत पहले नहीं, स्कॉट मेयर्स, सी ++ प्रोग्रामिंग भाषा के विशेषज्ञ, कई प्रसिद्ध पुस्तकों के लेखक, ने सी ++ 11 में प्रतिद्वंद्विता लिंक का उपयोग करने के विवरण का वर्णन करते हुए एक लेख प्रकाशित किया था।
यह विषय अभी तक हैबे पर नहीं उठाया गया है, और मुझे लगता है कि यह लेख समुदाय के लिए हितकारी होगा।
मूल लेख: "C ++ 11 में सार्वभौमिक संदर्भ - स्कॉट मेयर्स"

C ++ 11 में यूनिवर्सल लिंक

T && का अर्थ हमेशा "संदर्भ संदर्भ" नहीं होता है

द्वारा पोस्ट किया गया: स्कॉट मेयर्स

शायद C ++ 11 में सबसे महत्वपूर्ण नवाचार लिंक लिंक है। वे उस नींव के रूप में सेवा करते हैं जिस पर "स्थानांतरण के शब्दार्थ (अंग्रेजी चाल शब्दार्थ)" और "परिपूर्ण अग्रेषण" निर्मित होते हैं। (आप थॉमस बेकर की समीक्षा में इन तंत्रों की मूल बातें से खुद को परिचित कर सकते हैं)।

Syntactically, rvalue लिंक को "सामान्य" लिंक (अब lvalue लिंक कहा जाता है) की तरह घोषित किया जाता है, सिवाय इसके कि आप एक के बजाय दो एम्परसेंड का उपयोग करते हैं। इस प्रकार, यह फ़ंक्शन टाइप-रेवल्यू-रेफरेंस-टू-विजेट के एक पैरामीटर को स्वीकार करता है:

void f(Widget&& param); 

यह देखते हुए कि rvalue सन्दर्भों को && का उपयोग करके घोषित किया जाता है, यह मानना ​​उचित होगा कि एक प्रकार की घोषणा में && की उपस्थिति एक रवैल्यू सन्दर्भ को इंगित करती है। लेकिन ऐसा नहीं है:

 Widget&& var1 = someWidget; //  “&&”  rvalue  auto&& var2 = var1; //  “&&”   rvalue  template<typename T> void f(std::vector<T>&& param); //  “&&”  rvalue  template<typename T> void f(T&& param); //  “&&”   rvalue  

इस अनुच्छेद में, मैं एक प्रकार की घोषणा में "और&" के दो अर्थों का वर्णन करूंगा, उन्हें एक दूसरे से अलग करने का तरीका समझाऊंगा और नई शब्दावली का परिचय दूंगा जो हमें स्पष्ट रूप से यह निर्धारित करने की अनुमति देगा कि "और&" का कौन सा अर्थ उपयोग किया जाता है। विभिन्न मानों को हाइलाइट करना महत्वपूर्ण है क्योंकि यदि आप एक प्रकार की घोषणा में "&&" देखते हैं तो "rvalue लिंक" के बारे में सोचते हैं, आप C ++ 11 कोड की एक बड़ी मात्रा को गलत समझेंगे।

मुद्दा यह है कि && एक प्रकार की घोषणा में एक लिंक का अर्थ है, लेकिन कभी-कभी इसका अर्थ या तो एक लिंक लिंक या एक लिंक लिंक हो सकता है। इस प्रकार, कुछ मामलों में, स्रोत कोड में "&&" का मान "और", अर्थात् हो सकता है। वाक्यविन्यास में एक रवैल्यू रेफरेंस ("&&") का रूप होता है, लेकिन वास्तव में एक लैवल्यू रेफरेंस ("और") होता है।

लिंक एक अधिक लचीली अवधारणा हैं, जो लिंक या लिंक लिंक की तुलना में अधिक लचीली होती हैं। तो प्रतिद्वंद्विता लिंक केवल एक प्रतिद्वंद्विता के साथ जुड़ा हो सकता है, और अंतराल लिंक, एक अंतराल के साथ बांधने में सक्षम होने के अलावा, सीमित परिस्थितियों में एक प्रतिद्वंद्विता के साथ जुड़ा जा सकता है (अंतराल लिंक और प्रतिबंध जोड़ने पर प्रतिबंध है कि इस तरह के लिंकिंग केवल तभी स्वीकार्य है जब एक लैवल्यू लिंक एक स्थिर के संदर्भ के रूप में घोषित किया जाता है, अर्थात, T &।) लिंक, && के साथ घोषित किया जाता है, जो या तो लिंक या लिंक लिंक से लिंक किया जा सकता है, जिसे किसी भी चीज़ के साथ जोड़ा जा सकता है। ऐसे असामान्य रूप से लचीले लिंक उनके नाम के लायक हैं। मैंने उन्हें "सार्वभौमिक" लिंक कहा ।

"&&" का विवरण जब एक सार्वभौमिक संदर्भ का अर्थ है (जब स्रोत कोड में "&&" का वास्तव में अर्थ हो सकता है "और") काफी जटिल हैं, तो मैं उनके विवरण को स्थगित कर दूंगा। अब, निम्नलिखित नियम पर ध्यान दें, क्योंकि दैनिक प्रोग्रामिंग करते समय आपको यही याद रखना चाहिए:

यदि कुछ घटाए गए प्रकार T के लिए T या& के साथ एक चर या पैरामीटर घोषित किया जाता है, तो ऐसा चर या पैरामीटर एक सार्वभौमिक संदर्भ है।

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

T && यूनिवर्सल लिंक घोषणा फॉर्म एक अधिक महत्वपूर्ण आवश्यकता है जितना यह लग सकता है, लेकिन मैं इस मुद्दे पर बाद में लौटूंगा। इस बीच, बस इस आवश्यकता को ध्यान में रखें।

सभी लिंक की तरह, यूनिवर्सल लिंक को इनिशियलाइज़ किया जाना चाहिए, और यह यूनिवर्सल लिंक इनिशलाइज़र है, जो यह निर्धारित करता है कि क्या यह एक लैवल्यू लिंक या एक रैवल्यू लिंक होगा:

• यदि सार्वभौमिक सन्दर्भ को आरम्भ करने वाली अभिव्यक्ति एक लवल्यू है, तो सार्वभौमिक सन्दर्भ एक लैवल्यू सन्दर्भ बन जाता है।
• यदि सार्वभौमिक सन्दर्भ को आरम्भ करने वाला व्यंजक आवेग है, तो सार्वभौमिक सन्दर्भ एक सन्दर्भ संदर्भ बन जाता है।

यह जानकारी केवल तभी उपयोगी है जब आप लवलीन को प्रतिद्वंद्विता से अलग करने में सक्षम हों। इन शर्तों की एक सटीक परिभाषा पर काम करना मुश्किल है (C ++ 11 मानक एक सामान्य परिभाषा देता है कि क्या अभिव्यक्ति एक मामले से दूसरे स्थान पर है या नहीं), लेकिन व्यवहार में निम्नलिखित पर्याप्त है:

• यदि आप अभिव्यक्ति का पता ले सकते हैं, तो यह अभिव्यक्ति है।
• यदि अभिव्यक्ति का प्रकार एक लैवल्यू संदर्भ है (यानी, टीएंड या कास्ट टी एंड, आदि), तो यह एक्सप्रेशन है।
• अन्यथा, अभिव्यक्ति एक प्रतिद्वंद्विता है। वैचारिक रूप से (और आमतौर पर, वास्तव में), अस्थाई अस्थायी वस्तुओं के अनुरूप होते हैं, जैसे कि कार्यों से लौटे या अंतर्निहित प्रकार रूपांतरण द्वारा बनाए गए। अधिकांश शाब्दिक (जैसे 10 और 5.3) भी व्याप्त हैं।

आइए लेख की शुरुआत से कोड को फिर से देखें:

 Widget&& var1 = someWidget; auto&& var2 = var1; 

आप पता var1 ले सकते हैं, क्रमशः var1 एक अंतराल है। Var2 को ऑटो और& के रूप में घोषित करना var2 को एक सार्वभौमिक संदर्भ बनाता है, और चूंकि इसे var1 (lvalue) द्वारा प्रारंभ किया जाता है, var2 एक lvalue संदर्भ बन जाता है।

स्रोत कोड के लापरवाह पढ़ने से आपको यह विश्वास हो सकता है कि var2 एक संदर्भ संदर्भ है; विज्ञापन में "और&", निश्चित रूप से, इस विचार की ओर जाता है। लेकिन चूंकि var2 एक सार्वभौमिक संदर्भ है जिसे एक लैवल्यू द्वारा आरंभ किया गया है, यह एक लैवल्यू संदर्भ है। यह वैसा ही है जैसे कि var2 को इस प्रकार घोषित किया गया था:

 Widget& var2 = var1; 

जैसा कि ऊपर उल्लेख किया गया है, अगर अभिव्यक्ति लिंक के अंतराल प्रकार की है, तो यह एक अंतराल है। इस उदाहरण पर विचार करें:

 std::vector<int> v; ... auto&& val = v[0]; // val  lvalue  (. ) 

वैल एक सार्वभौमिक संदर्भ है और आरंभीकृत v [0], यानी कॉलिंग एसटीडी का परिणाम :: वेक्टर <int> :: ऑपरेटर []। यह फ़ंक्शन वेक्टर तत्व का एक अंतराल संदर्भ देता है (मैं सरणी से परे जाने की उपेक्षा करता हूं, जिससे अपरिभाषित व्यवहार हो जाएगा)।

चूँकि सभी लैवल्यू संदर्भ लैवल्यूज़ हैं, और चूंकि इस लैवल्यू का उपयोग वैली को इनिशियलाइज़ करने के लिए किया जाता है, इसलिए वैल एक लैवल्यू रेफ़रेंस बन जाता है, हालाँकि वैल-टाइप घोषणा एक रेवल्यू संदर्भ की तरह दिखता है।

मैंने नोट किया कि फ़ंक्शन टेम्प्लेट मापदंडों में सार्वभौमिक लिंक सबसे आम हैं। इस लेख की शुरुआत से फिर से टेम्पलेट पर विचार करें।

 template<typename T> void f(T&& param); // “&&”   rvalue  

इस तरह के एक कॉल के साथ,

 f(10); // 10  rvalue 

परम को शाब्दिक 10 के साथ आरंभीकृत किया गया है, जो इस कारण से कि इसका पता नहीं लिया जा सकता है, एक प्रतिद्वंद्विता है। इसका मतलब यह है कि कॉल टू एफ में, यूनिवर्सल परम रेफरेंस को आरव्यू के लिए इनिशियलाइज़ किया जाता है और इस तरह रैवल्यू रेफरेंस बन जाता है-विशेष रूप से int &&

दूसरी ओर, अगर f को कुछ इस तरह कहा जाता है:

 int x = 10; f(x); // x  lvalue 

पैराम को वेरिएबल x से इनिशियलाइज़ किया जाता है, इस कारण से कि आप इसका पता ले सकते हैं, लैवल्यू है। इसका मतलब यह है कि इस कॉल टू f में, यूनिवर्सल परम रेफ़रेंस को एक लैवल्यू में इनिशियलाइज़ किया गया है, और इसलिए परम सटीक होने के लिए –L & - के लिए लैवल्यू रेफरेंस बन जाता है।

F की घोषणा के आगे की टिप्पणी अब स्पष्ट होनी चाहिए: क्या परम प्रकार एक लवल्यू संदर्भ है या एक रवैल्यू रेफरेंस इस बात पर निर्भर करता है कि कॉल के दौरान f को क्या दिया गया था। कभी-कभी परम एक रेवले संदर्भ बन जाता है, और कभी-कभी एक रेवले संदर्भ। यही है, परम वास्तव में एक सार्वभौमिक संदर्भ है।

याद रखें कि && केवल एक सार्वभौमिक संदर्भ को दर्शाता है जब प्रकार का अनुमान होता है। जहाँ कोई प्रकार का अनुमान नहीं है, वहाँ कोई सार्वभौमिक संदर्भ नहीं है। ऐसे मामलों में, एक प्रकार की घोषणा में "&&" हमेशा एक संदर्भ संदर्भ का मतलब होता है। इसलिए:

 template<typename T> void f(T&& param); //    ⇒  ; && ≡   template<typename T> class Widget { ... Widget(Widget&& rhs); //     ⇒   ; ... // && ≡ rvalue  }; template<typename T1> class Gadget { ... template<typename T2> Gadget(T2&& rhs); //    ⇒  ; && ≡   }; void f(Widget&& param); //     ⇒   ; // && ≡ rvalue  

इन उदाहरणों में आश्चर्य की कोई बात नहीं है। किसी भी स्थिति में, यदि आप T && (जहां T टेम्प्लेट पैरामीटर है) देखते हैं, तो टाइप इंफ़ेक्शन मौजूद होता है, इसलिए आप एक सार्वभौमिक लिंक देख रहे हैं। और यदि आप एक निश्चित प्रकार के नाम (उदाहरण के लिए, विजेट और&) के बाद "&&" देखते हैं, तो आप rvalue लिंक को देखते हैं।

मैंने कहा था कि लिंक के लिए लिंक घोषणा पत्र "T &&" होना चाहिए ताकि लिंक सार्वभौमिक हो। यह एक महत्वपूर्ण अति सूक्ष्म अंतर है। इस लेख की शुरुआत से घोषणा को फिर से देखें:

 template<typename T> void f(std::vector<T>&& param); // “&&”  rvalue  

यहाँ हमारे पास दोनों प्रकार के निष्कर्ष हैं और "&&" - वर्णित फ़ंक्शन पैरामीटर है, लेकिन पैरामीटर का घोषित रूप "T &&" नहीं है, लेकिन "std :: वेक्टर <T> &&" है। नतीजतन, पैरामीटर एक सामान्य संदर्भ संदर्भ है, न कि एक सार्वभौमिक संदर्भ। एक सार्वभौमिक लिंक घोषणा केवल "T &&" के रूप में हो सकती है! यहां तक ​​कि एक कांस्टेबल क्वालीफायर को जोड़ने के लिए "&&" की व्याख्या एक सार्वभौमिक संदर्भ के रूप में नहीं है।

 template<typename T> void f(const T&& param); // “&&”  rvalue  

सार्वभौमिक लिंक घोषित करने के लिए "T &&" केवल एक आवश्यक रूप है। इसका मतलब यह नहीं है कि आपको टेम्पलेट मापदंडों के लिए टी नाम का उपयोग करना चाहिए।

 template<typename MyTemplateParamType> void f(MyTemplateParamType&& param); // “&&”    

कभी-कभी आप टेम्पलेट फ़ंक्शन घोषणापत्र में T && देख सकते हैं, जहां T एक टेम्पलेट पैरामीटर है, लेकिन अभी तक कोई प्रकार का निष्कर्ष नहीं है। Std :: वेक्टर में push_back फ़ंक्शन पर विचार करें (केवल हमारे लिए रुचि का संस्करण दिखाया गया है

 std::vector::push_back): template <class T, class Allocator = allocator<T> > class vector { public: ... void push_back(T&& x); //     ⇒   ; ... // && ≡ rvalue  }; 

यहाँ T एक टेम्प्लेट पैरामीटर है, और push_back T && को स्वीकार करता है। हालांकि, पैरामीटर एक सार्वभौमिक संदर्भ नहीं है! यह कैसे हो सकता है?

उत्तर स्पष्ट हो जाता है अगर हम देखते हैं कि कक्षा के बाहर पुश_बैक कैसे घोषित किया जाएगा। मैं यह दिखावा करूंगा कि एलोकेटर पैरामीटर गायब है ताकि कोड को अव्यवस्थित न किया जाए। इसे देखते हुए, इस संस्करण की घोषणा निम्नलिखित है
std :: वेक्टर :: push_back:

 template <class T> void vector<T>::push_back(T&& x); 

push_back std के बिना मौजूद नहीं हो सकता है :: वेक्टर <T> वर्ग जिसमें यह शामिल है। लेकिन अगर हमारे पास वर्ग एसटी :: वेक्टर <टी> है, तो हम पहले से ही जानते हैं कि टी क्या है, और इस प्रकार, इस प्रकार को कटौती करने की कोई आवश्यकता नहीं है।

एक उदाहरण देखते हैं। अगर मैं लिखता हूँ

 Widget makeWidget(); //    Widget std::vector<Widget> vw; ... Widget w; vw.push_back(makeWidget()); //  Widget    vw 

तब push_pack का मेरा उपयोग कंपाइलर को इस फ़ंक्शन को std :: वेक्टर <विजेट> वर्ग के लिए तुरंत बता देगा। कक्षा के बाहर उसकी घोषणा इस तरह दिखाई देगी:

 void std::vector<Widget>::push_back(Widget&& x); 

क्या आप समझते हैं? जैसे ही हम जानते हैं कि वर्ग std :: वेक्टर <विजेट> है, पुश_बैक पैरामीटर का प्रकार पूरी तरह से परिभाषित है। प्रकार का अनुमान नहीं किया जाता है।
इसकी तुलना emplace_back std :: वेक्टर विधि से करें, जो निम्नानुसार घोषित की गई है:

 template <class T, class Allocator = allocator<T> > class vector { public: ... template <class... Args> void emplace_back(Args&&... args); //    ⇒  ; ... // && ≡   }; 

इस तथ्य पर ध्यान न दें कि emplace_back तर्क की एक चर संख्या को स्वीकार करता है (जैसा कि आर्ग्स और आर्गन्स घोषणा में बताया गया है)। यहाँ जो महत्वपूर्ण है वह यह है कि प्रत्येक तर्क के प्रकारों का अनुमान होना चाहिए। Args फ़ंक्शन का टेम्प्लेट पैरामीटर वर्ग T के टेम्पलेट पैरामीटर से स्वतंत्र है, इसलिए भले ही वर्ग पूरी तरह से ज्ञात हो, std :: वेक्टर <विजेट> कहो, यह emplace_back तर्कों के प्रकार (ओं) के बारे में कुछ नहीं कहता है। Std :: वेक्टर <विजेट> के लिए कक्षा के बाहर की गई emplace_back घोषणा स्पष्ट रूप से यह दिखाती है (मैं एलोकेटर पैरामीटर के अस्तित्व को अनदेखा करना जारी रखता हूं):

 template<class... Args> void std::vector<Widget>::emplace_back(Args&&... args); 

जाहिर है, यह जानते हुए कि वर्ग std :: वेक्टर <विजेट> emplace_back को दिए गए प्रकार (ओं) को घटाने की आवश्यकता को समाप्त नहीं करता है। नतीजतन, std :: वेक्टर :: emplace_back पैरामीटर std के विपरीत सार्वभौमिक लिंक हैं :: वेक्टर :: push_back संस्करण पैरामीटर, जो, जैसा कि हमने देखा, एक प्रतिद्वंद्विता लिंक है।

इस बात का ध्यान रखें कि क्या अभिव्यक्ति एक स्वर है या एक स्वर अपने प्रकार से स्वतंत्र है। प्रकार int पर विचार करें। वहाँ प्रकार int (जैसे int द्वारा घोषित चर) का एक अंतराल है और प्रकार int (जैसे शाब्दिक, उदाहरण 10) का एक अंतराल है। यह विजेट जैसे कस्टम प्रकारों के लिए सही है। एक विजेट ऑब्जेक्ट एक लैवल्यू (उदाहरण के लिए, एक विजेट चर) या एक रिवेल्यू हो सकता है (उदाहरण के लिए, फ़ैक्टरी फ़ंक्शन ने बनाई गई विजेट ऑब्जेक्ट वापस कर दिया है)। अभिव्यक्ति का प्रकार आपको यह नहीं बताएगा कि यह एक अंतराल है या एक प्रतिद्वंद्विता है।

 Widget makeWidget(); //    Widget Widget&& var1 = makeWidget(); // var1  lvalue,   // var1 –  rvalue  ( Widget) Widget var2 = static_cast< Widget&& >(var1); // cast   rvalue,  //   -  rvalue  ( Widget) 

लेवेल्यू (उदाहरण के लिए var1) को एक रैवल्यू में बदलने का एक सामान्य तरीका std :: move का उपयोग करना है, इसलिए var2 को इस प्रकार परिभाषित किया जा सकता है:

 Widget var2 = std::move(var1); //    

मैंने मूल रूप से केवल स्पष्ट रूप से दिखाने के लिए static_cast का उपयोग करते हुए कोड का हवाला दिया कि अभिव्यक्ति का प्रकार एक संदर्भ संदर्भ (विजेट और&) है।

नाम प्रकार के चर और मापदंडों के प्रकार rvalue संदर्भ lvalue हैं। (आप उनका पता प्राप्त कर सकते हैं।) एक बार फिर, विजेट और गैजेट टेम्पलेट्स पर विचार करें:

 template<typename T> class Widget { ... Widget(Widget&& rhs); //  rhs - rvalue , ... //  rhs  lvalue }; template<typename T1> class Gadget { ... template <typename T2> Gadget(T2&& rhs);// rhs      ... //     rvalue   }; // lvalue ,  rhs  lvalue 

विजेट निर्माण में, rhs एक रेवल्यू रेफरेंस है, इसलिए हम जानते हैं कि यह एक रिवेल्यू (यानी रिवेल्यू पास किया गया था) से जुड़ा हुआ है, लेकिन rhs ही एक लैवल्यू है, इसलिए हमें इसका फायदा उठाने के लिए इसे फिर से रिवैल्यू में बदलना होगा। कि rhs rueue से संबंधित है। हमारी इच्छा, एक नियम के रूप में, एक हस्तांतरण स्रोत के रूप में rhs का उपयोग करने की आवश्यकता के कारण है, इसलिए ldue को rvalue में बदलने के लिए std :: Move का उपयोग किया जाता है। इसी तरह, गैजेट कंस्ट्रक्टर में rhs एक सार्वभौमिक संदर्भ है, और इसलिए इसे एक अंतराल के साथ या एक प्रतिद्वंद्विता के साथ जोड़ा जा सकता है, लेकिन किसी भी मामले में, rhs खुद एक अंतराल है। यदि यह व्याप्तता से संबंधित है और हम इसका लाभ उठाना चाहते हैं, तो हमें rhs को पुनरावृत्ति में बदलना चाहिए। हालांकि, अगर यह एक अंतराल के साथ जुड़ा हुआ है, तो हम निश्चित रूप से इसे एक प्रतिद्वंद्विता के रूप में नहीं मानना ​​चाहते हैं। सार्वभौमिक लिंक के साथ जुड़ा हुआ है पर यह निर्भरता std :: अग्रेषित का उपयोग करने का कारण है: सार्वभौमिक लिंक लेने के लिए और इसे केवल प्रतिद्वंद्विता अभिव्यक्ति के साथ जुड़ा होने पर इसे परिवर्तित करने के लिए। फ़ंक्शन का नाम ("आगे") हमारी अपेक्षाओं की पुष्टि करता है कि यह दूसरे फ़ंक्शन में स्थानांतरित हो जाएगा, हमेशा तर्क के प्रकार (बचाव या अंतराल) को संरक्षित करता है।

लेकिन std :: Move and std :: आगे इस लेख का विषय नहीं हैं। लेख इस तथ्य के बारे में बात करता है कि प्रकार की घोषणाओं में && शायद लिंक लिंक का वर्णन नहीं कर सकता है या नहीं। विचलित न होने के लिए, मैं आपको "अतिरिक्त सूचना" अनुभाग में लिंक का उल्लेख करता हूं, जो कि std :: Move और std :: आगे के विस्तृत विवरण के लिए है।

छोटे विवरण

मुद्दा यह है कि सी ++ 11 में कुछ निर्माण लिंक के लिंक उत्पन्न करते हैं, और लिंक के लिंक सी ++ में अनुमति नहीं हैं। यदि स्रोत कोड में स्पष्ट रूप से लिंक का लिंक है, तो कोड गलत है:

 Widget w1; ... Widget& & w2 = w1; // !     “  ” 

हालांकि, ऐसे मामले हैं जहां लिंक के लिंक संकलन के दौरान होने वाले प्रकारों के साथ छेड़छाड़ के परिणामस्वरूप उत्पन्न होते हैं, और ऐसे मामलों में, इस कोड को अस्वीकार करना समस्याग्रस्त होगा। हम इसे C ++ के लिए मूल मानक के अनुभव से जानते हैं, अर्थात, C ++ 98 / C ++ 03।

टेम्प्लेट मापदंडों के लिए टाइप इंट्रेंस के दौरान, जो एक सार्वभौमिक संदर्भ है, एक ही प्रकार का लवल्यू और रेवल्यू कई अलग-अलग प्रकारों के लिए आउटपुट हैं। विशेष रूप से, टाइप टी का एक प्रकार टी के रूप में आउटपुट होता है (यानी, टी के लिए एक अंतराल संदर्भ), और टाइप टी का एक प्रकार केवल टी के रूप में आउटपुट होता है। (ध्यान दें कि एक लैवल्यू एक लैवल्यू संदर्भ के रूप में आउटपुट है, रिवेल्यू संदर्भ के रूप में आउटपुट नहीं है!) विचार करें कि क्या होता है जब आप एक टेम्प्लेट फ़ंक्शन को कॉल करते हैं जो एक सार्वभौमिक संदर्भ को स्वीकार करता है, जो अंतराल और अंतराल के साथ है:

 template<typename T> void f(T&& param); ... int x; ... f(10); //  f  rvalue f(x); //  f  lvalue 

10 T के साथ f को कॉल करने के लिए, यह इंट के रूप में प्रिंट करता है और f की तात्कालिकता इस तरह दिखती है:

 void f(int&& param); // f   rvalue 

यह अच्छा है। हालांकि, lvalue x के साथ f करने के लिए कॉल में, T इंट & के रूप में आउटपुट है, और f इंस्टेंस में लिंक का लिंक है:

 void f(int& && param); //   f  lvalue 

लिंक के लिंक के कारण, यह इंस्टेंस कोड पहली नज़र में गलत लगता है, लेकिन स्रोत कोड "f (x)" काफी उचित है। इस कोड को अस्वीकार न करने के लिए, C ++ "लिंक फोल्डिंग" करता है जब किसी लिंक का लिंक किसी टेम्प्लेट को इंस्टेंट करने जैसे संदर्भों में दिखाई देता है।

चूंकि दो प्रकार के लिंक (लवल्यू लिंक और रिवेल्यू लिंक) होते हैं, लिंक लिंक के चार संभावित संयोजन होते हैं: लैवल्यू लिंक से लेवल्यू लिंक, रेवल्यू लिंक के लिए लेवल्यू लिंक, रेवल्यू लिंक से लेवल्यू लिंक और रिवेल्यू लिंक से रिवेल्यू लिंक। लिंक तह के केवल दो नियम हैं:

• एक प्रतिद्वंद्विता लिंक के लिए एक कड़ी लिंक ("टूट जाता है") एक अंतराल लिंक बन जाता है।
• लिंक के अन्य सभी लिंक (यानी, सभी लिंक जिसमें lvalue लिंक शामिल हैं) एक lvalue लिंक में ढह गए हैं।

इन नियमों को एक lvalue के साथ च को तुरंत लागू करने से निम्नलिखित सही कोड प्राप्त होते हैं:

 void f(int& param); //  f  lvalue    

यह सटीक तंत्र प्रदान करता है जिसके द्वारा एक सार्वभौमिक लिंक (प्रकार के संबंध और लिंक को मोड़ने के बाद) को एक अंतराल लिंक में बदल दिया जा सकता है। वास्तव में, एक सार्वभौमिक लिंक लिंक फोल्डिंग के संदर्भ में एक मात्र लिंक है।

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

 int x; ... int&& r1 = 10; //  r1 - int&& int& r2 = x; //  r2 - int& 

तब टेम्पलेट को कॉल करते समय r1 और r2 दोनों के प्रकार को int माना जाता है। लिंक छोड़ने का यह व्यवहार सामान्य प्रकारों के प्रकार प्रकार के नियमों पर निर्भर नहीं करता है, लैवल्यू टी टाइप के रूप में आउटपुट हैं, और टाइप टी के रूप में रिवेल्यू, और इस प्रकार इन कॉलों में,

 f(r1); f(r2); 

r1 और r2 दोनों के लिए घटाया गया प्रकार int & होगा। क्यों? सबसे पहले, प्रकार r1 और r2 के संदर्भ भाग को छोड़ दिया जाता है (यह दोनों मामलों में int बाहर निकलता है), फिर, चूंकि यह एक अंतराल है, दोनों को f के रूप में कॉल में सार्वभौमिक संदर्भ पैरामीटर के लिए int और प्रकार के अनुमान के रूप में माना जाता है।

लिंक तह होता है, जैसा कि मैंने उल्लेख किया है, "संदर्भ में जैसे कि एक टेम्पलेट को तत्काल करना"। दूसरा ऐसा संदर्भ "ऑटो" चर की परिभाषा है। ऑटो चर के लिए टाइप इंट्रेंस, जो सार्वभौमिक संदर्भ हैं, फ़ंक्शन टेम्प्लेट मापदंडों के लिए टाइप इंट्रेंस के समान अनिवार्य रूप से समान हैं, जो कि यूनिवर्सल रेफरेंस हैं, क्योंकि टाइप टी का एक लैवल्यू टाइप T & होने का आउटपुट है, और टाइप T का एक रिव्यू टाइप T & होने के बाद आउटपुट है। लेख की शुरुआत से फिर से उदाहरण पर विचार करें:

 Widget&& var1 = someWidget; // var1   Widget&& (auto  ) auto&& var2 = var1; // var2   Widget& (. ) 

प्रकार var1, विजेट && है, लेकिन इसके "संदर्भ भाग" को प्रकार 2 के प्रारंभ के दौरान प्रकार के अनुमान के दौरान अनदेखा किया जाता है; इसे एक प्रकार का विजेट माना जाता है। चूंकि यह एक अंतराल है जो एक सार्वभौमिक संदर्भ (var2) को इनिशियलाइज़ करने के लिए उपयोग किया जाता है, जो घटाया गया प्रकार विजेट और होगा। वर्सेट्यूलिंग विजेट और var2 परिभाषा में ऑटो के बजाय, हमें निम्नलिखित अमान्य कोड मिलते हैं,

 Widget& && var2 = var1; //       

जो मोड़ने के बाद लिंक बन जाएंगे

 Widget& var2 = var1; // var2   Widget& 

लिंक फोल्डिंग के लिए तीसरा संदर्भ टाइपडेफ का गठन और उपयोग है। इस वर्ग टेम्पलेट को देखते हुए

 template<typename T> class Widget { typedef T& LvalueRefType; ... }; 

और इस टेम्पलेट का उपयोग,

 Widget<int&> w; 

तात्कालिक वर्ग में निम्नलिखित (अमान्य) टाइपफेड शामिल होंगे:

 typedef int& & LvalueRefType; 

फोल्डिंग लिंक निम्न मान्य कोड की ओर जाता है:

 typedef int& LvalueRefType; 

यदि हम इस संदर्भ में इसका उपयोग करते हुए संदर्भ में इस टाइपफेड का उपयोग करते हैं, उदाहरण के लिए,

 void f(Widget<int&>::LvalueRefType&& param); 

टाइपराइफ तैनात होने के बाद, निम्नलिखित अवैध कोड उत्पन्न हो जाएगा,

 void f(int& && param); 

लेकिन लिंक को मोड़ने से यह छोटा हो जाएगा और f की अंतिम घोषणा होगी:

 void f(int& param); 

अंतिम संदर्भ जहां लिंक फोल्डिंग का उपयोग किया जाता है, डिक्लेपट का उपयोग करना है। टेम्प्लेट और ऑटो की तरह, घोषणापत्र एक अभिव्यक्ति के प्रकार का प्रदर्शन करता है, जो या तो T या T & पैदावार देता है, और घोषित करता है तो C ++ 11 लिंक तह नियम लागू करता है।

दुर्भाग्य से, घोषणापत्र द्वारा उपयोग किए जाने वाले लिंक तह नियम एक टेम्पलेट या ऑटो प्रकार के लिए एक प्रकार का बचाव करते समय समान नहीं होते हैं। विवरण यहां चर्चा करने के लिए बहुत जटिल हैं (विवरण के लिए लिंक के लिए "अधिक जानकारी" अनुभाग देखें), लेकिन ध्यान देने योग्य अंतर यह है कि गैर-संदर्भ प्रकार के नामित चर के लिए घोषित टाइप टी (यानी एक संदर्भ प्रकार नहीं), जब कुछ शर्तों के तहत होता है। टेम्पलेट्स और ऑटो प्रकार टी एंड प्रकार का अनुमान लगाते हैं। एक अन्य महत्वपूर्ण अंतर यह है कि डिक्वेस्ट टाइप इंट्रेंस केवल एक्सप्रेशन के डिक्लेपट पर निर्भर करता है; आरंभिक अभिव्यक्ति का प्रकार (यदि कोई हो) को नजरअंदाज किया जाता है। इसलिए:

 Widget w1, w2; auto&& v1 = w1; // v1   , //  lvalue,  v1 //  lvalue   w1. decltype(w1)&& v2 = w2; // v2   ,  decltype(w1)  Widget, //   v2  rvalue . // w2  lvalue,    // rvalue  lvalue,      . 

निष्कर्ष

एक प्रकार के विवरण में, "&&" का अर्थ या तो एक लिंक या सामान्य लिंक है - एक लिंक जो या तो एक लिंक लिंक या एक लिंक है। यूनिवर्सल लिंक हमेशा कुछ अनुमानित प्रकार के लिए T && फॉर्म लेते हैं। T.

लिंक फोल्डिंग यूनिवर्सल लिंक्स को जोड़ने के लिए तंत्र है (जो उन स्थितियों में केवल लिंक लिंक का उपयोग किया जाता है) कभी-कभी लिंक को लिंक करने के लिए और कभी-कभी लिंक को लिंक करने के लिए। इसका उपयोग विशेष संदर्भों में किया जाता है जिसमें संकलन के परिणामस्वरूप लिंक दिखाई दे सकते हैं। ये एक प्रकार के टेम्पलेट को संदर्भित करने, ऑटो-प्रकार का संदर्भ देने, टाइप करने के लिए जेनरेट करने और उपयोग करने और संदर्भ घोषित करने के संदर्भ हैं।

धन्यवाद

इस लेख के ड्राफ्ट संस्करणों की समीक्षा कैसियो नेरी, मिखल मोकेनी, हॉवर्ड हाइनेंट, आंद्रेई अलेक्जेंड्रेस्कु, स्टेफ़न टी। लावेज, रोजर ओर, क्रिस ओल्डवुड, जोनाथन वेक्ली और एंथनी विलियम्स ने की है। उनकी टिप्पणियों ने लेख में महत्वपूर्ण सुधार में योगदान दिया, साथ ही इसकी प्रस्तुति भी।

अतिरिक्त जानकारी

सी ++ 11, विकिपीडिया।

नई C ++ (C ++ 11) का अवलोकन, स्कॉट मेयर्स, आर्टिमा प्रेस, अंतिम बार जनवरी 2012 को अपडेट किया गया।

C ++ रिवेल्यू रेफरेंस समझाया, थॉमस बेकर, अंतिम बार सितंबर 2011 में अपडेट किया गया

।

"एक नोट के बारे में घोषणा," एंड्रयू Koenig, डॉ। डोब की, 27 जुलाई, 2011।