क्या यह एक चालक कन्स्ट्रक्टर में स्थिरता को दूर करने के लिए स्वीकार्य है?

Question

मान लीजिए मैं एक वर्ग फू के लिए एक निजी सूचक है कि एक बार:

class Foo 
{ 
private: 
    Bar * bar; 

public: 
    Foo() : bar (new Bar()) 
    {} 

    ~Foo() 
    { 
    delete bar; 
    } 
}; 

सूचक bar कभी नहीं एक अलग उदाहरण को सौंप दिया जाना चाहिए, तो यह समझ में सूचक ही बनाने के लिए बनाता है क्रम में const मुझे (या एक मेंटेनर) भविष्य में ऐसा करने से रोकने के लिए:

private: 
    Bar * const bar; 

मैं यह कर रहा पसंद जहाँ भी अवसर मिले।

मैं तो एक कदम निर्माता लिखना चाहते थे, तो यह कुछ इस तरह दिखेगा:

Foo (Foo && f) : 
    bar (f.bar) 
{ 
    f.bar = NULL; // uh oh; f.bar is const. 
} 

मैं या तो f.bar की constness दूर कास्टिंग द्वारा या यह नहीं बना द्वारा "त्रुटि दूर जाने" कर सकते हैं पहली जगह में बांधो। इनमें से कोई भी चीज नहीं है जो मैं करना चाहता हूं। मैं पूरी तरह से कॉन्स को नहीं हटाऊंगा क्योंकि यह किसी कारण से है। दूसरी ओर, मेरे लिए स्थिरता रिंग अलार्म घंटी कास्टिंग और कुछ ऐसा है जो मैं आमतौर पर नहीं करता हूं। मेरा सवाल है: क्या इसे इस तरह के एक चालक कन्स्ट्रक्टर के भीतर स्थिरता को दूर करने के लिए स्वीकार्य अभ्यास माना जाता है? क्या कोई बेहतर तरीका है जिसे मैंने नहीं माना है?

मुझे नहीं लगता कि मेरे सवाल यह वैसा ही है जैसा: Use const_cast to implement the move constructor

Answer 1

यदि आपको किसी मामले में पॉइंटर बदलना होगा (भले ही यह केवल एक ही मामला है), तो शायद यह const नहीं होना चाहिए।

हालांकि, किसी ऑब्जेक्ट से स्थिरता को हटाने के लिए const_cast का उपयोग करके, और फिर कास्ट के नतीजे का उपयोग करके अपरिभाषित व्यवहार का उपयोग करके इस विचार को अलग रखा गया। यह केवल const_cast एक चर है जो मूल रूप से कॉन्स्ट नहीं था। यदि संभव हो

Answer 2

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

तो, यदि कोई परिदृश्य है जहां इसे बदलने की जरूरत है, तो यह const नहीं है, और आप इसे आसानी से हटा सकते हैं।

यदि आप निर्धारित हैं कि आप इसे const चाहते हैं, तो आप एक और बूलियन मान जोड़ सकते हैं जो स्वामित्व निर्धारित करता है (यदि आपको संसाधन जीवनकाल को संभालने की आवश्यकता है)। तो बिंदु वस्तु केवल तभी जारी की जा सकती है जब ऑब्जेक्ट का मालिक बनने वाले विनाशक को बुलाया जाता है।

Answer 3

, unique_ptr बजाय का उपयोग करें:

std::unique_ptr<Bar> bar; 
Foo(Foo&& f) : bar(std::move(f.bar)){} 
// or maybe you won't even have to declare move constructor 

इस तरह न केवल आप और अधिक सुरक्षा और आराम मिल जाएगा, लेकिन यह भी आप गलती से = साथ यह पुनर्लेखन नहीं होगा, तो आप .reset() फोन करना होगा तो आप इसे करने से पहले दो बार सोचेंगे (जो आपका लक्ष्य है, मुझे लगता है)।