¿Eliminar operador y matrices?

Question

Tengo un abstractBase clase y Derived clase.

int main() 
{ 
    Base *arrayPtr[3]; 

    for (int i = 0; i < 3; i++) 
    { 
    arrayPtr[i] = new Derived(); 
    } 

    //some functions here 

    delete[] arrayPtr; 

    return 0; 
} 

No estoy seguro de cómo usar el operador de eliminación. Si elimino una matriz de punteros de clase base como se muestra arriba, ¿esta llamada derivará los objetos de la clase destructores y limpiará la memoria?

Answer 1

Tienes que iterar sobre los elementos de la matriz, delete cada uno de ellos. Luego llame al delete [] en la matriz si se ha asignado dinámicamente usando new[].

En su código de ejemplo, la matriz se asigna en la pila por lo que no debe llamar al delete [].

También asegúrese de que su clase Base tenga un destructor virtual.

Referencia: When should my destructor be virtual.

Answer 2

No, usted tiene que eliminar explícitamente cada elemento de la matriz:

for (int i = 0; i < 3; ++i) 
{ 
    delete arrayPtr[i]; 
} 

Answer 3

su lugar, debe hacer:

for (int = i; i < 3; i++) 
{ 
    delete arrayPtr[i]; 
} 

Y usted no debe hacer delete[] arrayPtr; como usted está tratando de libre/borrar una pila asignado arrayPtr.

Otra cosa a considerar es utilizar un std::vector de punteros en lugar de una matriz. Y si está utilizando un compilador que implementa TR1, también podría usar un std::vector de std::tr1::shared_ptr en lugar de punteros sin procesar, y entonces no tendría que preocuparse por eliminar esos objetos usted mismo.

Ejemplo:

{ 
    std::vector< std::tr1::shared_ptr<Base> > objects; 
    for (int i=0; i < 3; ++i) 
    { 
     objects.push_back(std::tr1::shared_ptr<Base>(new Derived())); 
    } 
} // here, once "objects" exit scope, all of your Derived objects are nicely deleted 

Answer 4

Asegúrese Base tiene un destructor virtual. Luego, como fretje outlined, elimine cada elemento de la matriz y luego elimine la matriz.

Debe utilizar std::vector para la matriz. Dicho esto, debería realmente utilizar un contenedor hecho para este tipo de cosas. (Por lo tanto, no se puede eliminar accidentalmente todos los elementos, lo que sin duda será el caso si se lanza una excepción). Boost tiene such a library.

Answer 5

Debe eliminar los miembros de la matriz individualmente. También debe asegurarse de que su clase base tenga un destructor virtual. También es posible que desee considerar hacer una matriz (o mejor aún un std :: vector) de punteros inteligentes, como boost :: shared_ptr.

Answer 6

No, no puedes hacer eso. Como otros sugirieron que tienes que revisar cada elemento y eliminarlo. Es una regla muy simple para recordar. Si se distribuyen utilizando new a continuación, utilizar delete, y si se hubiera usado new[] a continuación, utilizar delete[]

Answer 7

No, esto no es hacer lo que quiera.

Hay dos puntos a tener en cuenta aquí:

1. la sintaxis delete[] arrayPtr se utiliza si asigna dinámicamente la matriz, así:

   arrayPtr = new (Base *)[mylength]; 
   

   En su caso, sin embargo, tener una matriz estáticamente asignada, por lo que no hay necesidad de eliminarla. Usted, sin embargo, tiene que eliminar los elementos individuales de la matriz:

   for (int = i; i < 3; i++) 
       delete arrayPtr[i]; 
   

2. El segundo punto es necesario cuidar es hacer que el destructor de la clase Base virtual:

   class Base 
   { 
       virtual ~Base(); 
       /* ... */ 
   }; 
   

   Esto garantiza que cuando se invoca delete en un Base * que apunta a un Derived, se llama al destructor de Derived, no solo al destructor de Base.

Answer 8

Aviso lo que está ausente:

int main() { 
    boost::ptr_vector<Base> v; 
    for (int i = 0; i < 3; i++) v.push_back(new Derived()); 
    // some functions here, using v[0] through v[2] 
} 

Comprobar Boost's pointer containers a cabo.

Answer 9

La eliminación del operador debe coincidir con el operador nuevo en ese puntero, si fue asignado con new[], debe llamar al delete[] y viceversa;

int* pInt = new int; 
delete pInt; OK 
delete [] pInt; WRONG 

int[] pIntArr = new int[3]; 
delete [] pIntArr; OK 
delete pIntArr; WRONG 

En su caso hay algo más malo - que están tratando de delete que fue asignado en la pila. Eso no funcionaria

Debe borrar cada puntero de forma individual en este caso particular.

Answer 10

Lo que tienes allí es un comportamiento indefinido, un error. Cada llamada al new debe coincidir con un delete; cada llamada a new[] debe coincidir con un delete[]. Los dos están separados y no se pueden mezclar.

En el código que ha publicado, tiene una serie de punteros a Base asignados en la pila. Entonces llama al delete[] en una matriz asignada en la pila; no puede hacer eso. Solo puede delete[] una matriz asignada en el montón con new[].

Necesita una llamada al delete para cada elemento asignado con new - o preferiblemente, investigue utilizando una clase de contenedor, como std::vector, en lugar de usar una matriz.

Answer 11

Está mezclando paradigmas: el operador de eliminación de matriz está diseñado para liberar memoria asignada por el nuevo operador de matriz, pero está asignando su matriz a la pila como una matriz de punteros y luego asignando un objeto para cada matriz miembro. En su código, necesita iterar a través de la matriz.

Para utilizar la matriz del nuevo operador, que le declara así:

Base *array; 
array = new Base[3]; 
/* do stuff */ 
delete[] array; 

Esto asigna un área de memoria contigua para los tres objetos - en cuenta que tienes una gran variedad de objetos de la base, no una matriz de punteros a los objetos Base.