स्थानांतरित किए जाने वाले वस्तुओं से स्थानांतरित हो गए हैं?

Question

यदि मैं b से a को स्थानांतरित करता हूं, तो क्या यह आवश्यकb को नष्ट करने के लिए है, या क्या मैं ऐसा करने से दूर हो सकता हूं?

यह प्रश्न optional<T> टेम्पलेट के कार्यान्वयन के दौरान मेरे दिमाग को पार कर गया। अंश:

~optional() 
{ 
    if (initialized) 
    { 
     reinterpret_cast<T*>(data)->~T(); 
    } 
} 

optional(optional&& o) : initialized(o.initialized) 
{ 
    if (initialized) 
    { 
     new(data) T(std::move(*o)); // move from o.data 
     o.initialized = false;  // o.data won't be destructed anymore! 
    } 
} 

बेशक

, मैं सिर्फ bool initialized एक थ्री-वैल्यूड गणन कि के बीच प्रारंभ, गैर प्रारंभ और ले जाया गया-से अलग के साथ बदल सकते थे। मैं सिर्फ यह जानना चाहता हूं कि यह सख्ती से जरूरी है या नहीं।

Answer 1

हां, b को नष्ट करना अभी भी आवश्यक है। वस्तु से स्थानांतरित एक वैध, निर्मित वस्तु है। कुछ मामलों में, यह उन संसाधनों को भी पकड़ सकता है जिन्हें अभी भी निपटान करने की आवश्यकता है। जेनेरिक कोड जैसे आप दिखाते हैं, T में एक चालक कन्स्ट्रक्टर भी नहीं हो सकता है। आप इस मामले में बदले में एक प्रतिलिपि बना सकते हैं। तो आप निश्चित रूप से यह नहीं मान सकते कि ~ टी() एक नो-ऑप है और इसे elided किया जा सकता है।

Answer 2

हां, आपको अभी भी उन्हें नष्ट करना है। इस दोष को दिखाए जाने वाले डिज़ाइनों में से एक उदाहरण के लिए, पर्यवेक्षक-आधारित पैटर्न है जहां एक ऑब्जेक्ट पॉइंटर्स की सूचियों को दूसरे में रखता है। विनाशक नहीं चल रहा है पॉइंटर को नहीं हटाएगा और जब कोड किसी ऑब्जेक्ट तक पहुंचने का प्रयास करता है तो कोड क्रैश हो जाएगा जो अब मौजूद नहीं है।

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

Answer 3

मैं आपके प्रश्न पर 'नहीं' का उत्तर देना चाहता हूं लेकिन मुझे यकीन नहीं है कि यह पूछने का भी सही सवाल है। निम्नलिखित पर विचार करें:

{ // start of scope 
    T maybe_moved; 
    if(some_condition) { 
     T(std::move(maybe_moved)); 
    } 
// end of scope 
} 

T::~T() स्पष्ट रूप से केवल maybe_moved वस्तु के लिए एक बार बुलाया जाना चाहिए। यदि कोई चालक कन्स्ट्रक्टर इसे कॉल करेगा, तो आप इस तरह के निर्दोष कोड कैसे काम करेंगे?