हमें व्यावहारिक रूप से 'स्पष्ट xvalues' की आवश्यकता कब होती है?

Question

XValue की परिभाषा निम्नानुसार है:

- एक XValue (एक "समाप्त हो रहा है" मूल्य) भी इतना है कि अपने संसाधनों से ले जाया जा सकता है आम तौर पर अपने जीवनकाल के अंत के पास, एक वस्तु को संदर्भित करता है (, उदाहरण के लिए)। एक xvalue कुछ प्रकार के अभिव्यक्तियों का परिणाम है जिसमें रावल संदर्भ (8.3.2) शामिल हैं। [उदाहरण: फ़ंक्शन को कॉल करने का नतीजा जिसका रिटर्न टाइप एक रावल्यू संदर्भ है, एक xvalue है। उदाहरण के लिए]

क्या हम कभी भी ऐसे फ़ंक्शन का उपयोग करने की आवश्यकता रखते हैं जहां वापसी का प्रकार एक रावल्यू संदर्भ है, जो एक xvalue है?

const int && Foo() 
{ 
    // ... 
} 

ले जाएं semantics एक पैरामीटर के रूप में एक रैल्यू संदर्भ ले, वापसी मूल्य नहीं। तो मुझे नहीं लगता कि यह मामला है।

Answer 1

रिटर्निंग रेवल्यू संदर्भ उन कार्यों के लिए उपयोग किए जा सकते हैं जो पैरामीटर के रूप में पहले ही रावल लेते हैं। एक साधारण उदाहरण:

struct X { 
    X() = default; 
    X(X&& other) { std::cout << "move ctor\n"; } 
    X(X const&) = delete; 
    void log(std::string const& s){ std::cout << "log: " << s << "\n"; } 
}; 

void sink(X&& x) { 
    x.log("sink"); 
} 

X&& passOn(X&& in) { 
    in.log("pass"); 
    return std::move(in); 
} 

X moveOn(X&& in) { 
    in.log("move"); 
    return std::move(in); 
} 

int main() { 
    sink(passOn(X())); 
    std::cout << "===============================\n"; 
    sink(moveOn(X())); 
} 

Live demo →

दूसरा समारोह, लौटे वस्तु बनाने के लिए कदम निर्माता फोन, जबकि पहला संदर्भ यह पहले से ही मिल गया पर पारित करेंगे होगा। यह अधिक उपयोगी है अगर हम मूल संदर्भ वापस नहीं करते हैं बल्कि इसके बजाय निर्दिष्ट वस्तु के एक हिस्से के संदर्भ में हैं, उदाहरण के लिए

template<class T> 
T&& getHead(std::vector<T>&& input) { 
    return std::move(input.front()); 
} 

Answer 2

यह ठीक है std::move है - std::move निष्पादन का परिणाम एक xvalue है। इसके अलावा यह कहना मुश्किल है क्योंकि मुख्य रूप से फ़ंक्शन से संदर्भ लौटने में मुख्य बात एक बुरी चीज है। लेकिन शायद कोई इस तरह के एक समारोह के एक और चालाक उपयोग के साथ आ जाएगा।

Answer 3

क्या हम कभी भी ऐसे फ़ंक्शन का उपयोग करने की आवश्यकता रखते हैं जहां वापसी का प्रकार एक रावल्यू संदर्भ है, जो एक xvalue है?

यह कंटेनर कक्षाओं में इस्तेमाल, उदाहरण के लिए tuple एक get अधिभार कि इस तरह दिखता है है:

template< std::size_t I, class... Types > 
typename std::tuple_element<I, tuple<Types...> >::type&& 
    get(tuple<Types...>&& t); 

मुझे लगता है कि std::optional और std::variant में सी ++ 17 दोनों एक समान भार के होगा।

दी, केवल बात कुछ बहुत ही विशेष परिस्थितियों में std::move टाइप करने के लिए, की तरह से बचने के लिए है:

auto x = std::get<1>(f()); 

कहाँ f मूल्य द्वारा एक टपल देता है।