सी ++ 11 रिटर्न मूल्य अनुकूलन या स्थानांतरित करें?

Question

मुझे समझ नहीं नहीं जब मैं std::move का उपयोग करना चाहिए और जब मैं संकलक का अनुकूलन देना चाहिए ... उदाहरण के लिए:

using SerialBuffer = vector< unsigned char >; 

// let compiler optimize it 
SerialBuffer read(size_t size) const 
{ 
    SerialBuffer buffer(size); 
    read(begin(buffer), end(buffer)); 
    // Return Value Optimization 
    return buffer; 
} 

// explicit move 
SerialBuffer read(size_t size) const 
{ 
    SerialBuffer buffer(size); 
    read(begin(buffer), end(buffer)); 
    return move(buffer); 
} 

कौन सा उपयोग करना चाहिए?

Answer 1

उपयोग विशेष रूप से पहली विधि:

Foo f() 
{ 
    Foo result; 
    mangle(result); 
    return result; 
} 

यह पहले से ही चाल निर्माता का उपयोग करते हैं, यदि उपलब्ध है की अनुमति देगा। वास्तव में, एक स्थानीय चर return कथन में एक रैल्यू संदर्भ से जुड़ा हो सकता है जब प्रतिलिपि की अनुमति दी जाती है।

आपका दूसरा संस्करण सक्रिय रूप से कॉपी एलिशन को प्रतिबंधित करता है। पहला संस्करण सार्वभौमिक रूप से बेहतर है।

Answer 2

सभी वापसी मान या तो पहले से ही moved या अनुकूलित किए गए हैं, इसलिए वापसी मूल्यों के साथ स्पष्ट रूप से स्थानांतरित करने की आवश्यकता नहीं है।

कंपाइलर्स को स्वचालित रूप से वापसी मूल्य (प्रतिलिपि को अनुकूलित करने के लिए) को स्थानांतरित करने की अनुमति है, और यहां तक ​​कि चाल को अनुकूलित भी करें!

n3337 मानक प्रारूप (सी ++ 11) की धारा 12.8:

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

[.. ।]

उदाहरण: स्थानीय स्वत: वस्तु t की नकल समारोह की वापसी मूल्य के लिए अस्थायी वस्तु में:

class Thing { 
public: 
Thing(); 
    ~Thing(); 
    Thing(const Thing&); 
}; 

Thing f() { 
    Thing t; 
    return t; 
} 

Thing t2 = f(); 

यहाँ इलिजन के लिए मापदंड वर्ग Thing की प्रतिलिपि निर्माता करने के लिए दो कॉल समाप्त करने के लिए जोड़ा जा सकता है f() और ऑब्जेक्ट t2 में उस अस्थायी वस्तु की प्रतिलिपि बनाना। प्रभावी रूप से, स्थानीय ऑब्जेक्ट t का निर्माण सीधे वैश्विक ऑब्जेक्ट t2 को प्रारंभ करने के रूप में देखा जा सकता है, और उस ऑब्जेक्ट का विनाश प्रोग्राम बाहर निकलने पर होगा। Thing पर एक चालक कन्स्ट्रक्टर जोड़ना एक ही प्रभाव है, लेकिन यह अस्थायी ऑब्जेक्ट से t2 पर चलने वाला निर्माण है जो कि elided है। - अंत उदाहरण]

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

Answer 3

यदि आप स्थानीय चर लौट रहे हैं, तो move() का उपयोग न करें। यह कंपाइलर को एनआरवीओ का उपयोग करने की अनुमति देगा, और उसमें असफल होने पर, कंपाइलर को अभी भी एक चाल करने की अनुमति दी जाएगी (स्थानीय चर return कथन के भीतर आर-मान बन जाते हैं)। उस संदर्भ में move() का उपयोग करने से एनआरवीओ को बाधित किया जाएगा और संकलक को एक चाल का उपयोग करने के लिए मजबूर किया जाएगा (या यदि कोई स्थान अनुपलब्ध है तो एक प्रतिलिपि)। यदि आप स्थानीय चर के अलावा कुछ और लौट रहे हैं, तो एनआरवीओ वैसे भी एक विकल्प नहीं है और आपको move() का उपयोग करना चाहिए यदि (और केवल अगर) आप वस्तु को पुल करने का इरादा रखते हैं।

Answer 4

यह काफी आसान है।

return buffer;

आप ऐसा करते हैं, तो या तो NRVO क्या होगा या यह नहीं होगा। यदि ऐसा नहीं होता है तो buffer से स्थानांतरित हो जाएगा।

return std::move(buffer);

आप ऐसा करते हैं, तो NVRO ऐसा नहीं जाएगा, और buffer से ले जाया जाएगा।

तो यहां std::move का उपयोग करके लाभ उठाने के लिए कुछ भी नहीं है, और बहुत कुछ खोना है।

Buffer read(Buffer&& buffer) { 
    //... 
    return std::move(buffer); 
} 

तो buffer एक rvalue संदर्भ है, तो आप std::move उपयोग करना चाहिए:

इस नियम के लिए एक अपवाद नहीं है। ऐसा इसलिए है क्योंकि संदर्भ एनआरवीओ के लिए योग्य नहीं हैं, इसलिए std::move के बिना इसके परिणामस्वरूप एक प्रतिभा से एक प्रतिलिपि होगी।

यह सिर्फ नियम "हमेशा move rvalue संदर्भ और forward सार्वभौमिक संदर्भ" है, जो शासन पर पूर्वता लेता है "कभी नहीं move एक वापसी मान" का एक उदाहरण है।