मैं बस पेड़ ही बदल जाएगा, यह तो इससे निपटने के लिए आसान होगा:
struct Node
{
Node(data_type data): mLeft(), mRight(), mData(data) {}
Node(const Node& rhs): mLeft(), mRight(), mData(rhs.mData)
{
if (rhs.mLeft.get()) mLeft.reset(new Node(*rhs.mLeft));
if (rhs.right.get()) mRight.reset(new Node(*rhs.mRight));
}
Node& operator=(Node rhs)
{
this->swap(rhs);
return *this;
}
~Node() { }
void swap(Node& rhs)
{
using std::swap;
swap(mLeft, rhs.mLeft);
swap(mRight, rhs.mRight);
swap(mData, rhs.mData);
}
Node* left() const { return mLeft.get(); }
void left(std::auto_ptr<Node> node) { mLeft= node; }
Node* right() const { return mRight.get(); }
void right(std::auto_ptr<Node> node) { mRight = node; }
data_type& data() { return mData; }
const data_type& data() const { return mData; }
private:
std::auto_ptr<Node> mLeft;
std::auto_ptr<Node> mRight;
data_type mData;
};
वस्तु उन्मुख किया जा रहा से, प्रत्येक नोड अब स्मृति यह संभालती के लिए जिम्मेदार है। इसके अलावा, का उपयोग करते हुए std::auto_ptrइंटरफ़ेस में यह स्पष्ट है कि यह स्वामित्व लेता है बनाता है।
ध्यान दें कि यह गहरे प्रतिलिपि बनाने के लिए अनुरूप किया गया है, किसी भी अन्य दृष्टिकोण की आवश्यकता होती है boost::shared_ptrया समकक्ष। और हाँ std::auto_ptrआप खुद ही नकल के साथ काम कर, कोई जादू वहाँ छोड़ देता है।
इस डिजाइन एक सादे का उपयोग करने से अधिक स्वच्छ है C-structहर किसी के संसाधनों में हेरफेर करने में सक्षम होने के साथ। तुम अब भी एक्सेसर के माध्यम से अंतर्निहित डेटा पर पहुंच सकते हैं ... लेकिन वे अपरिभाषित व्यवहार आह्वान करने के लिए नहीं ख्याल रखना ...
बेशक, आप अभी भी कुचल सकता है नीचे:
Node& node = ...
delete node.left(); // haha
लेकिन अगर सी ++ अनायास ही मुद्दों के खिलाफ की रक्षा कर सकते हैं, यह दरवाजा बुराई कोड के लिए खुला छोड़ देता है।
