¿Qué está sucediendo durante la declaración `delete this;`?

Question

Por favor, considere el siguiente código:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this;} 
private: 
    int x; 
}; 

Lo que está pasando (y es válido?) En las dos opciones siguientes:

la opción 1:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
    delete a; 
} 

opción 2:

void main() 
{ 
    foo a; 
    a.done(); 
} 

Será la segunda declaración delete a; en opt ion 1 causará una excepción o corrupción de montón?

¿La opción 2 causará una excepción o corrupción de montón?

Answer 1

delete this; está permitido, elimina el objeto.

Ambos fragmentos de código tienen un comportamiento indefinido: en el primer caso, eliminar un objeto que ya se ha eliminado y, en el segundo caso, eliminar un objeto con duración de almacenamiento automático.

Dado que el comportamiento no está definido, la norma no indica si provocarán una excepción o daños en el montón. Para diferentes implementaciones, puede ser cualquiera de los dos, y puede o no ser el mismo cada vez que ejecutas el código.

Answer 2

Ambos causarían un error.

La primera puntero se suprime dos veces, con el segundo delete que causa el error mientras que la segunda se asigna en la pila y no se puede eliminar implícitamente (error causado por primera invocación de destructor).

Answer 3

Ambos se producirá un error, lo que quiere es:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
} 

la que el compilador se expandirá a algo parecido a continuación, que espero marcas borrar "este" un poco menos confuso.

void __foo_done(foo* this) 
{ 
    delete this; 
} 

void main() 
{ 
    foo* a = new foo(); 
    __foo_done(a); 
} 

Véase también, Is it legal (and moral) for a member function to say delete this?

Answer 4

Calling delete this es una mala idea. Quien llame al new debe llamar al delete. De ahí los problemas como se destaca en las otras respuestas.

También puede tener fugas de memoria/comportamiento indefinido al construir una matriz de objetos.

Answer 5

En ambos casos, su pila se dañará. Por supuesto, no puede usar en la opción 2 "->" si el valor de la izquierda (en este caso, "a") no es un puntero, la forma correcta en la opción 2 sería a.done(); Pero sí, debería obtener un montón de corrupción si intenta eliminar 1) lo que ya se ha eliminado, o 2) variable local.

Llamar "eliminar esto" es técnicamente válido y libera la memoria.

EDITAR tenía curiosidad y, de hecho intentado esto:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this; } 
    void test() { x = 2; } 
    int getx() { return x; } 
private: 
    int x; 
} ; 


int main(int argc, char* argv[]) 
{ 
    foo *a = new foo(); 
    a->done(); 
    a->test(); 
    int x = a->getx(); 
    printf("%i\n", x); 
    return x; 
} 

Una llamada a printf tendrá éxito, y x contendrá el valor 2.

Answer 6

Sería muy cauteloso sobre el contexto en el que liberas memoria. Mientras se llama "eliminar esto"; intentará liberar la memoria asociada con la estructura de clase, esa operación no tiene ningún medio de deducir el contexto de la asignación de memoria original, es decir, si se asigna desde el montón o la pila. Mi consejo sería volver a trabajar su código para que la operación de desasignación se invoque desde un contexto externo. Tenga en cuenta que esto es diferente de las estructuras de desasignación internas de la clase, en ese caso, use el destructor.

Answer 7

Esta pregunta ha sido respondida, pero añadiré un nuevo punto que indica que si su clase llama a eliminar esto, también debe hacer que el destructor sea privado.

Esto asegura que solo la clase puede eliminarse.

Si hace que su destructor sea privado, las dos muestras de código no podrán compilarse.