C ++ 11 में मान और कॉन्स्टेबल चर द्वारा लौटें

कई प्रोग्रामिंग भाषाओं में, वस्तुओं और चर को निरंतर घोषित करना संभव है। और, तदनुसार, ऐसा करने के लिए सिफारिशें हैं यदि आप उनके मूल्यों को बदलने नहीं जा रहे हैं। नए मानक के आगमन के साथ, सी ++ में एक सिफारिश दिखाई गई है कि वस्तुओं को मूल्य से वापस किया जाए, क्योंकि आरवीओ के बिना भी आप आंदोलन के शब्दार्थ का उपयोग करके कार्यक्रम के प्रदर्शन में सुधार कर सकते हैं। यदि हम इन दो सिफारिशों का एक साथ उपयोग करते हैं तो क्या होगा: मूल्य द्वारा स्थिर वस्तु लौटाएं? आइए इसे आगे जानने की कोशिश करते हैं।

हाल ही में C ++ के सम्मेलन से वीडियो देखकर, मैं एक दिलचस्प बिंदु (गड्ढे) में आया। भाषणों में से एक के अंत में, स्पीकर निम्नलिखित कोड देता है:

struct s { ... }; sf() { const sr; ...; return r; } 

और पूछता है कि फ़ंक्शन से वापस आने पर ऑब्जेक्ट r का क्या होता है?

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

C ++ 03 के बाद से, हम में से कई इस तथ्य के आदी हैं कि अस्थायी वस्तुएं और स्थिरांक लगभग एक ही चीज हैं। और यह तर्कसंगत है, क्योंकि उन दोनों का व्यवहार समान था: उन्होंने आपको केवल उन कार्यों को कॉल करने की अनुमति दी थी जो मूल्य या निरंतर संदर्भ द्वारा तर्क लेते हैं (या बस इन प्रकारों के लिए अपने मूल्यों को असाइन करते हैं):

 void f1(int a) { } void f2(int& a) { } void f3(const int& a) { } int g() { return 0; } int main() { f1(g()); // OK f2(g()); // compile error f3(g()); // OK const int a = 0; f1(a); // OK f2(a); // compile error f3(a); // OK } 

C ++ 11 में, स्थिति बदल गई है: अब हम rvalue संदर्भों का उपयोग करके अस्थायी वस्तुओं को बदल सकते हैं। लेकिन निरंतर नहीं। मानक के अनुसार, कॉन्स्टेंट स्पेसिफ़र के साथ घोषित वस्तुओं में कोई भी बदलाव (चाहे वह पॉइंटर्स के साथ कॉन्स्टैक या पॉवर्स का उपयोग कर रहा हो) अपरिभाषित व्यवहार की ओर जाता है। यह पता चलता है कि यदि कंपाइलर ने चाल निर्माणकर्ता का उपयोग करके कोड उत्पन्न किया, तो यह कार्यक्रम को अपरिभाषित स्थिति में डाल देगा, जो अस्वीकार्य है। दूसरे शब्दों में, समान अनुकूलन की तुलना में कंपाइलर के लिए कॉस्ट-शुद्धता की अधिक प्राथमिकता है। फिर भी, C ++ एक दृढ़ता से टाइप की जाने वाली भाषा है और कॉन्स्टेंस से नॉर्मल तक के रेफरेंस और पॉइंटर्स की कोई भी निहित कास्ट वर्जित है, उदाहरण के लिए: const A a -> A && ।

निम्नलिखित कोड पर विचार करें:

 void f1(int& a) { } void f2(const int& a) { } int main() { int a1 = 0; f1(a1); // OK int a2 = 0; f2(a2); // OK const int ca1 = 0; f1(ca1); // compile error const int ca2 = 0; f2(ca2); // OK } 

C ++ मानक ऑब्जेक्ट से क्वालिफायर हटाने की अनुमति नहीं देता है। यदि A का एक निश्चित प्रकार A और A दोनों को कम किया जा सकता है और A & को कब्ज किया जा सकता है, तो const A को केवल A & को कम किया जा सकता है अब लिंक के rvalue के साथ लिंक के lvalue को std जोड़कर प्रतिस्थापित करें: फंक्शन में पैरामीटर पास करते समय कॉल करें ... अत्यधिक! हम कास्ट ए को ए और ए के लिए नहीं डाल सकते हैं, लेकिन हम एएंडटी को कास्ट कर सकते हैं। यदि आप ऐसा कंस्ट्रक्टर लिखते हैं, तो कंपाइलर फ़ंक्शंस से लगातार वैरिएबल वापस करने के लिए इसका उपयोग करता है, लेकिन यह नियमित कॉपी कंस्ट्रक्टर की तुलना में अधिक समझ में नहीं आता है। इसलिए, इस प्रकार के लिंक का आमतौर पर उपयोग नहीं किया जाता है।

निष्कर्ष

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

 struct s { ... }; s foo(); s bar() { const auto r = foo(); if (r.check_something()) throw std::exception(); return r; } 

और यहां तक ​​कि इस कोड में ऑब्जेक्ट की एक प्रति (एक और नुकसान) है:

 s bar() { auto&& r = foo(); ...; return r; } 

इस विकल्प को प्राथमिकता दें:

 s bar() { auto r = foo(); ...; return r; } 

या, केवल यदि आप प्रत्येक चाल निर्माता को महत्व देते हैं:

 s bar() { auto&& r = foo(); ...; return std::move(r); } 

टिप्पणी

निम्न कोड के साथ पिछले उदाहरण को भ्रमित न करें जो एक लिंक लिंक लौटाता है:

 s&& bar() { auto&& r = foo(); ...; return std::move(r); } 

ऐसा कभी न करें, यहां पहले से ही नष्ट की गई वस्तु का लिंक दिया गया है।

और फोर्स आपके साथ हो सकती है!