¿Es una pérdida de memoria push_back un puntero en un vector de punteros?

Question

En mi clase, tengo una variable miembro std::vector<node*> children

¿La siguiente función miembro de clase crea una pérdida de memoria?

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

El vector hace una copia del puntero y tengo dos punteros a la misma memoria, y luego el original del puntero sale del ámbito, ¿verdad?

Esto puede ser simple y obvio, pero me gustaría confirmar mi suposición.
gracias

Answer 1

No es una fuga ... todavía. Sin embargo, si el vector sale del alcance, o erase, pop_back o hace algo más que elimina elementos del vector, sin el primer elemento delete que está eliminando, tendrá una fuga en sus manos.

La forma correcta de hacer esto es cambiar de usar vector<node *> a vector<unique_ptr<node>>. Su código cambiará a

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

O utilice boost::ptr_vector<node> si se puede usar Boost.

Answer 2

Es solo una pérdida de memoria si olvida desasignar el nodo secundario cuando se llama a la clase que contiene el destructor del vector.

Answer 3

No es una pérdida de memoria. Todavía tiene un puntero en el vector y podrá liberar la memoria cuando sea necesario.

Answer 4

Cuando el vector sale del alcance, es destructor no destruye el objeto apuntado. Destruye el puntero, lo que no hace nada.

Su código creó ese objeto a través de new. Su código es responsable de eliminar ese objeto. Si no lo haces, tienes una filtración. Si lo hace temprano, es decir, antes de quitar el puntero del vector, tiene problemas aún mayores.

Answer 5

Suponiendo que children es un miembro de la clase, simplemente eliminará todos los elementos del vector en el deconstructor de clase.

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); 

Si ha utilizado una vector<Foo>child lugar, cada push_back en el vector crearía una copia del objeto original que se almacenará, pero ya que estamos usando punteros, en este caso asignado en el montón por ningún objeto new se crea una copia, el puntero que apunta a un objeto de término de larga vida simplemente se almacena, lo que significa que sí, tiene que eliminarlo más tarde.