QList y shared_ptr

Question

¿Qué opinas? ¿Es correcto o hay pérdidas de memoria?

Fuente:

#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; 
} 

Salida:

6 
destroying A(6) 

Answer 1

Parece correcto. El shared_ptr de Boost es un puntero de conteo de referencia. El recuento de referencias puede reclamar memoria si no hay referencias circulares entre objetos. En su caso, los objetos de la clase A no hacen referencia a ningún otro objeto. Por lo tanto, puedes usar shared_ptr sin preocupaciones. Además, la semántica de propiedad permite que shared_ptrs se use en contenedores STL (y Qt).

Answer 2

Es difícil sugerir algo sin saber por qué la lista de shared_ptr s de A objetos existe en el primer lugar.

Eche un vistazo a ownership semantics de punteros inteligentes. Quizás de ayuda para ti.

Algunas otras cosas que se pueden mejorar:

1. listas Uso de inicializador en ctor como:

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

2.int _tmain(int argc, _TCHAR* argv[]) no es una firma estándar;

Uso

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

o simplemente:

int main() 

Answer 3

Este código se ve perfectamente bien.

Si está buscando asesoramiento, tal vez podría proporcionar más información sobre el propósito de utilizar shared_ptr con QList, podría haber una forma de "Qt" de hacer esto sin tirar de las grandes armas como shared_ptr.

Answer 4

Si no está utilizando un puntero inteligente, debe eliminar los elementos de la lista usted mismo.

Fuente:

#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; 
} 

Salida:

6 

No es bueno.