std :: move आगे का संदर्भ क्यों लेता है?

Question

std::move के कार्यान्वयन मूल रूप से इस तरह दिखता है:

template<typename T> 
typename std::remove_reference<T>::type&& 
move(T&& t) 
{ 
    return static_cast<typename std::remove_reference<T>::type&&>(t); 
} 

ध्यान दें कि std::move के पैरामीटर एक सार्वभौमिक संदर्भ है (यह भी एक अग्रेषण संदर्भ के रूप में जाना है, लेकिन हम यहाँ अग्रेषण नहीं हैं)।

std::string a, b, c; 
// ... 
foo(std::move(a));  // fine, a is an lvalue 
foo(std::move(b + c)); // nonsense, b + c is already an rvalue 

लेकिन चूंकि std::move के पूरे मुद्दे एक rvalue को कास्ट करने के लिए है, इसलिए हम भी std::move rvalues ​​करने की अनुमति है: यह तुम दोनों lvalues ​​और rvalues ​​std::move कर सकते हैं, है? std::move केवल लालच स्वीकार करेगा अगर यह अधिक समझ में नहीं आता है?

template<typename T> 
T&& 
move(T& t) 
{ 
    return static_cast<T&&>(t); 
} 

तब बकवास अभिव्यक्ति std::move(b + c) संकलन-समय त्रुटि उत्पन्न करेगी।

std::move के उपरोक्त कार्यान्वयन को शुरुआती लोगों के लिए समझना बहुत आसान होगा, क्योंकि कोड ठीक वही करता है जो ऐसा लगता है: यह एक लालसा लेता है और एक रैल्यू देता है। आपको सार्वभौमिक संदर्भ, संदर्भ ढहने और मेटा कार्यों को समझने की आवश्यकता नहीं है।

तो std::move क्यों था lvalues ​​और rvalues ​​दोनों लेने के लिए बनाया गया था?

Answer 1

यहां कुछ उदाहरण चरम करने के लिए सरल है:

#include <iostream> 
#include <vector> 

template<typename T> 
T&& my_move(T& t) 
{ 
    return static_cast<T&&>(t); 
} 

int main() 
{ 
    std::vector<bool> v{true}; 

    std::move(v[0]); // std::move on rvalue, OK 
    my_move(v[0]); // my_move on rvalue, OOPS 
} 

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

Answer 2

यह चोट नहीं पहुंचाता है।

आप बस एक गारंटी स्थापित कर रहे हैं कि कोड परिणामस्वरूप एक रावल्यू के रूप में व्यवहार करेगा। आप निश्चित रूप से std :: move लिख सकते हैं इस तरह से कि यह किसी चीज से निपटने में त्रुटिपूर्ण हो जो पहले से ही एक रावल्यू है, लेकिन लाभ क्या है?

जेनेरिक कोड में, जहां आपको जरूरी नहीं है कि आप किस प्रकार के काम के साथ काम करने जा रहे हैं, अभिव्यक्ति में क्या लाभ होगा, यदि आप रावल्यू के अलावा कुछ और नहीं करते हैं :: चाल "हर जगह plastered जब आप बस कह सकते हैं" मैं वादा करता हूँ कि हम इसे एक रावल्यू के रूप में सोच सकते हैं "।

आपने इसे स्वयं कहा, यह एक कलाकार से अधिक कुछ नहीं है। अगर तर्क पहले से ही इच्छित प्रकार से मेल खाता है तो _cast ऑपरेशंस भी असफल हो सकता है?