क्या यह पॉइंटर को वेक्टर के वेक्टर में पुश_बैक करने के लिए मेमोरी रिसाव है?

Question

मेरी कक्षा में, मेरे पास सदस्य चर std::vector<node*> children

क्या निम्न श्रेणी सदस्य फ़ंक्शन मेमोरी लीक बनाता है?

//adds a child node 
{ 
    node* child = new node("blah","blah","blah"); 
    child->Set_Parent(this); 
    children.push_back(child); //<- Is this ok? 
} 

वेक्टर सूचक की एक प्रतिलिपि बनाता है और मैं एक ही स्मृति, करने के लिए दो संकेत दिए गए और फिर मूल सूचक है, है ना दायरे से बाहर चला जाता है?

यह आसान और स्पष्ट हो सकता है, लेकिन मैं बस अपनी धारणा की पुष्टि करना चाहता हूं।
धन्यवाद

Answer 1

यह एक रिसाव नहीं है ... अभी तक। हालांकि, यदि vector गुंजाइश से बाहर हो जाता है, या आप erase, pop_back या ऐसा कुछ और करते हैं जो वेक्टर से तत्वों को हटा देता है, बिना किसी तत्व के delete तत्व को हटाकर आप अपने हाथों पर एक रिसाव लेंगे।

ऐसा करने का सही तरीका vector<node *> से vector<unique_ptr<node>> का उपयोग करने से बदलना है। आपका कोड

//adds a child node 
{ 
    node* child = new node("blah","blah","blah"); 
    child->Set_Parent(this); 
    children.push_back(std::unique_ptr<node>(child)); 
} 

को बदलने के लिए या boost::ptr_vector<node> उपयोग करें यदि आप बूस्ट का उपयोग कर सकते हैं।

Answer 2

यदि आप वेक्टर के विनाशक वाले वर्ग को बुलाते हैं तो बच्चों के नोड को रद्द करना भूल जाते हैं, यह केवल एक स्मृति रिसाव है।

Answer 3

यह एक स्मृति रिसाव नहीं है। आपके पास अभी भी वेक्टर में एक पॉइंटर है और जब आवश्यक हो तो आप स्मृति को मुक्त कर पाएंगे।

Answer 4

जब वेक्टर गुंजाइश से बाहर हो जाता है, तो यह विनाशक बिंदु-वस्तु को नष्ट नहीं करता है। यह सूचक को नष्ट कर देता है - जो कुछ भी नहीं करता है।

आपके कोड ने new के माध्यम से उस ऑब्जेक्ट को बनाया है। आपका कोड उस ऑब्जेक्ट को हटाने के लिए ज़िम्मेदार है। यदि आप ऐसा नहीं करते हैं, तो आपके पास रिसाव है। यदि आप जल्दी ऐसा करते हैं, यानी, वेक्टर से सूचक को हटाने से पहले, आपको भी बड़ी समस्याएं होती हैं।

Answer 5

मान लीजिए children एक वर्ग सदस्य है, आप कक्षा deconstructor पर वेक्टर में बस सभी आइटम हटा देंगे।

struct Foo{}; 

class Bar 
{ 
public: 
    Bar(){}; 
    ~Bar() 
    { 
     for(vector<Foo*>::iterator it = children.begin(); it != children.end(); ++it) 
     { 
      SAFE_DELETE((*it)); //use your own macro/template or use delete if you don't have one 
      delete (*it); 
      (*it) = NULL; 
     } 
    } 
    vector<Foo*>children; 
} 

Foo* p = new Foo(); 
children.push_back(p); 

आप एक vector<Foo>child बजाय, वेक्टर मूल वस्तु की एक प्रतिलिपि बनाने हैं पर हर push_back संग्रहीत करने के लिए है, लेकिन आप संकेत का उपयोग कर रहे के बाद से, इस मामले new कोई वस्तु से ढेर पर आवंटित में प्रयोग किया जाता हैं प्रतिलिपि बनाई गई है, सूचक जो लंबे जीवनकाल ऑब्जेक्ट को इंगित करता है, बस संग्रहीत किया जाता है, जिसका अर्थ है हाँ, आपको इसे बाद में हटाना होगा।