क्या रावल्यू संदर्भ संदर्भों को लटकाने की अनुमति देते हैं?

Question

नीचे विचार करें।

#include <string> 
using std::string; 

string middle_name() { 
    return "Jaan"; 
} 

int main() 
{ 
    string&& danger = middle_name(); // ?! 
    return 0; 
} 

यह कुछ भी गणना नहीं करता, लेकिन यह त्रुटि के बिना संकलित करता है तथा कुछ है कि मैं संशय को दर्शाता है: danger एक झूलने संदर्भ है, है ना?

Answer 1

क्या रावल्यू संदर्भ संदर्भों को लटकाने की अनुमति देते हैं?

यदि आपका मतलब है "क्या यह खतरनाक रावल संदर्भों को बनाना संभव है" तो उत्तर हाँ है। आपका उदाहरण, हालांकि,

string middle_name() { 
    return "Jaan"; 
} 

int main() 
{ 
    string&& nodanger = middle_name(); // OK. 
    // The life-time of the temporary is extended 
    // to the life-time of the reference. 
    return 0; 
} 

बिल्कुल ठीक है। एक ही नियम यहां लागू होता है जो this example (हर्ब सटर द्वारा लेख) को सुरक्षित बनाता है। यदि आप शुद्ध रावल्यू के साथ संदर्भ प्रारंभ करते हैं, तो टेम्पोरी ऑब्जेक्ट का जीवनकाल संदर्भ के जीवनकाल तक बढ़ा दिया जाता है। हालांकि, आप अभी भी लटकने वाले संदर्भों का उत्पादन कर सकते हैं। उदाहरण के लिए, यह अब और सुरक्षित नहीं है:

int main() 
{ 
    string&& danger = std::move(middle_name()); // dangling reference ! 
    return 0; 
} 

क्योंकि std::move रिटर्न एक string&& (जो है एक शुद्ध rvalue नहीं) नियम यह है कि के अस्थायी जीवन समय लागू नहीं होता फैली हुई है। यहां, std::move एक तथाकथित xvalue देता है। एक xvalue सिर्फ एक अज्ञात रैल्यू संदर्भ है। जैसे कि यह कुछ भी संदर्भित कर सकता है और यह अनुमान लगाने के लिए मूल रूप से असंभव है कि एक लौटा संदर्भ संदर्भ के कार्यान्वयन को देखे बिना संदर्भित करता है।

Answer 2

danger एक खतरनाक संदर्भ है, है ना?

नहीं की तुलना में अगर आप एक const & का इस्तेमाल किया था किसी भी अधिक: danger rvalue के स्वामित्व लेता है।

Answer 3

रावल संदर्भ संदर्भों से बंधे हैं। एक रैल्यू या तो प्रावधान या xvalue [explanation] है। पूर्व के लिए बाध्यकारी कभी भी एक हानिकारक संदर्भ नहीं बनाता है, जो बाद की शक्ति के लिए बाध्यकारी हो सकता है। यही कारण है कि एक समारोह के रिटर्न प्रकार के रूप में T&& चुनना आम तौर पर एक बुरा विचार है। std::move इस नियम के लिए अपवाद है।

T& lvalue(); 
T prvalue(); 
T&& xvalue(); 

T&& does_not_compile = lvalue(); 
T&& well_behaved = prvalue(); 
T&& problematic = xvalue();