जब हम रैवल्यू संदर्भों का उपयोग करते हैं और std :: move कैसे काम करता है तो वास्तव में क्या होता है?

Question

मैं रैवल्यू संदर्भ को समझने और अर्थशास्त्र को स्थानांतरित करने की कोशिश कर रहा हूं। निम्नलिखित कोड में, जब मैं प्रिंट फ़ंक्शन पर 10 पास करता हूं तो यह रैवल्यू संदर्भ अधिभार को कॉल करता है, जिसकी अपेक्षा की जाती है। लेकिन वास्तव में क्या होता है, वह 10 कहां कॉपी हो जाएगा (या जहां से इसे संदर्भित किया गया है)। दूसरा, std::move वास्तव में क्या करता है? क्या यह i से मान 10 निकालता है और फिर इसे पास करता है? या यह रैल्यू संदर्भ का उपयोग करने के लिए संकलक के लिए निर्देश है?

void Print(int& i) 
{ 
    cout<<"L Value reference "<<endl; 
} 

void Print(int&& i) 
{ 
    cout<<"R Value reference "<< endl; 
} 

int main() 
{ 
    int i = 10; 

    Print(i); //OK, understandable 
    Print(10); //will 10 is not getting copied? So where it will stored 

    Print(std::move(i)); //what does move exactly do 

    return 0; 
} 

धन्यवाद।

Answer 1

लेकिन क्या वास्तव में जहां कि 10 की नकल की हो जाएगी, ऐसा होता है (या जहां यह संदर्भित किया जाता से)

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

दूसरा क्या std::move वास्तव में क्या करता है?

यह आपको रैवल्यू देता है इसके तर्क के संदर्भ में। यह समतुल्य (परिभाषा के अनुसार) static_cast<T&&> पर है।

नाम के बावजूद, यह कोई भी आंदोलन स्वयं नहीं करता है; यह आपको एक संदर्भ देता है जिसका उपयोग मूल्य को स्थानांतरित करने के लिए किया जा सकता है।

Answer 2

std::moveint&&static_cast<int&&> के माध्यम से। आखिरकार यदि प्रकार class या struct है, तो चालक को परिभाषित किया गया है (स्पष्ट रूप से या स्पष्ट रूप से) copy constructor/classical constructor के बजाय लागू किया जाएगा।

Answer 3

एक 10 के मामले में, वहाँ शायद वास्तविक क्रियान्वयन बदल जाएगा जो शामिल अनुकूलन होगा, लेकिन धारणात्मक, निम्न होता है:

• एक अस्थायी int बनाया है और मूल्य 10 साथ initialised है।

• वह अस्थायी int आर-मान संदर्भ फ़ंक्शन पैरामीटर से जुड़ा हुआ है।

तो अवधारणात्मक रूप से, कोई प्रतिलिपि नहीं है - संदर्भ अस्थायी को संदर्भित करेगा।

std::move() के लिए: संदर्भों से संबंधित कुछ मुश्किल बिट्स हो सकते हैं, लेकिन मुख्य रूप से, यह केवल आर-वैल्यू संदर्भ के लिए एक कलाकार है। std::move() वास्तव में स्थानांतरित करें। यह सिर्फ तर्क को आर-वैल्यू में बदल देता है, जिससे इसे स्थानांतरित किया जा सके।

"मूविंग" वास्तव में एक परिभाषित ऑपरेशन नहीं है, वैसे भी। हालांकि चलने के बारे में सोचना सुविधाजनक है, महत्वपूर्ण बात एल-वैल्यू बनाम आर-वैल्यू भेद है।

"मूविंग" सामान्य रूप से चालकों द्वारा संचालित किया जाता है, असाइनमेंट ऑपरेटरों को ले जाता है और आर-वैल्यू संदर्भ (जैसे push_back()) लेते हुए कार्य करता है। यह उनका कार्यान्वयन है जो इस कदम को एक वास्तविक कदम बनाता है - यानी, उन्हें लागू किया जाता है ताकि वे उन्हें कॉपी करने के बजाय आर-वैल्यू के संसाधनों को "चोरी" कर सकें। ऐसा इसलिए है क्योंकि, आर-वैल्यू होने के नाते, यह अब तक पहुंच योग्य नहीं होगा (या इसलिए आप संकलक का वादा करते हैं)।

यही कारण है कि std::move() "चलती" को सक्षम बनाता है - यह आर-वैल्यू, सिग्नलिंग में तर्क डालता है, "हे, कंपाइलर, मैं अब इस एल-वैल्यू का उपयोग नहीं करूँगा, आप फ़ंक्शंस (जैसे कि सीटीओ) इसे आर-वैल्यू के रूप में मानें और इससे चोरी करें। "