क्यूलिस्ट और साझा_ptr

Question

आपको क्या लगता है? क्या यह सही है या मेमोरी लीक हैं?

स्रोत:

#include <QList.h> 
#include <boost/shared_ptr.hpp> 
#include <iostream> 

class A { 
private: 
    int m_data; 
public: 
    A(int value=0) { m_data = value; } 
    ~A() { std::cout << "destroying A(" << m_data << ")" << std::endl; } 
    operator int() const { return m_data; } 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    QList<boost::shared_ptr<A> > list; 
    list.append(boost::shared_ptr<A>(new A(6))); 
    std::cout << int(*(list.at(0))) << std::endl; 
    return 0; 
} 

आउटपुट:

6 
destroying A(6) 

Answer 1

यह सही लगता है। बूस्ट का shared_ptr एक संदर्भ गिनती सूचक है। ऑब्जेक्ट्स के बीच कोई परिपत्र संदर्भ नहीं होने पर संदर्भ गिनती स्मृति को पुनः प्राप्त करने में सक्षम है। आपके मामले में, कक्षा ए की वस्तुएं किसी अन्य वस्तु का संदर्भ नहीं देती हैं। इस प्रकार, आप चिंताओं के बिना shared_ptr का उपयोग कर सकते हैं। साथ ही, स्वामित्व अर्थशास्त्र एसटीएल (और क्यूटी) कंटेनरों में साझा_ptrs का उपयोग करने की अनुमति देता है।

Answer 2

यह जानते हुए भी क्यों A वस्तुओं की shared_ptr रों की सूची पहली जगह में मौजूद के बिना कुछ भी सुझाव देने के लिए मुश्किल है।

स्मार्ट पॉइंटर्स के ownership semantics पर एक नज़र डालें। शायद आपकी मदद करो।

कुछ अन्य चीजें हैं जो सुधार किया जा सकता:

1. उपयोग प्रारंभकर्ता सूचियों ctor में की तरह:

class A { 
private: 
    int m_data; 
public: 
    A(int value=0) : m_data (value) {} 
// .... 

2.int _tmain(int argc, _TCHAR* argv[]) एक स्टैंडर्ड हस्ताक्षर नहीं है,

उपयोग

int main(int argc, char* argv[]) 

या बस:

int main() 

Answer 3

इस कोड को पूरी तरह से ठीक लग रहा है।

यदि आप सलाह चाहते हैं तो शायद आप QList के साथ shared_ptr का उपयोग करने के उद्देश्य से अधिक जानकारी प्रदान कर सकते हैं, तो साझा_प्टर जैसे बड़ी बंदूकें खींचने के बिना ऐसा करने का "क्यूटी" तरीका हो सकता है।

Answer 4

यदि आप स्मार्ट पॉइंटर का उपयोग नहीं कर रहे हैं, तो आपको अपने द्वारा सूची तत्वों को हटाना होगा।

स्रोत:

#include <QList.h> 
#include <boost/shared_ptr.hpp> 
#include <iostream> 

class A { 
private: 
    int m_data; 
public: 
    A(int value=0) { m_data = value; } 
    ~A() { std::cout << "destroying A(" << m_data << ")" << std::endl; } 
    operator int() const { return m_data; } 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    QList<A *> list; 
    list.append(new A(6)); 
    std::cout << int(*(list.at(0))) << std::endl; 
    return 0; 
} 

आउटपुट:

6 

अच्छा नहीं।