¿Por qué la pieza de código siguiente no se bloquea, aunque he eliminado el objeto?

Question

class object 
{ 
    public: 
    void check() 
    { 
     std::cout<<"I am doing ok..."<<std::endl; 
    } 
}; 

int main() 
{ 
    object *p = new object; 
    p->check(); 
    delete p; 
    p->check(); 
    delete p; 
    p->check(); 
} 

EDITAR: gurúes, Estoy confundido por muchas de las declaraciones "que puede bloquearse o no" .. ¿por qué tampoco existe una norma que dicen, así como nos ocupamos de un bloque de memoria que se elimina usando 'eliminar operador' ...? ¿Alguna entrada?

Answer 1

Porque lo que en realidad parece después de que el compilador ha salido con la suya, es algo como esto:

object::check(object* this) 
{ 
    // do stuff without using this 
} 

int main() 
{   
    object *p = new object; 
    object::check(p); 
    delete p; 
    object::check(p); 
    delete p; 
    object::check(p); 
} 

Puesto que usted "No estás tocando" esto ", no tienes acceso a ningún mal recuerdo.

Aunque, eliminando p dos veces debería ser capaz de causar un accidente:

http://www.parashift.com/c++-faq-lite/freestore-mgmt.html#faq-16.2

Answer 2

Porque la función no está haciendo nada con los datos del miembro del objeto o el puntero this.

Es como llamar a una función

void check(object *self) 
{ 
    std::cout<<"I am doing ok..."<<std::endl; 
} 

con un puntero no válido como argumento self.

Sin embargo, hay una eliminación doble, que puede fallar en algunos entornos.

Answer 3

Creo que depende del entorno (plataforma/compilador) ...
Esto al menos proporciona un comportamiento inesperado. I piensa que la suerte de que no se cuelga en su caso ;-)

Answer 4

eliminar sólo desasigna la memoria y hace que esté disponible de nuevo al montón.

El valor del puntero no está definido después de haber llamado a delete, por lo que puede bloquearse.

Una sugerencia de programación que utilizo para reducir errores de programación es después de una eliminación, establezca el puntero a NULL. De esta forma, sabrá que no está utilizando accidentalmente un puntero después de haber sido eliminado.

Answer 5

Aunque la llamada al método utilizara este puntero, no se garantizaría su bloqueo. El puntero p cuando se borra no se está poniendo a cero, por lo que sigue apuntando a la misma dirección en la memoria. Dependiendo de la implementación de new/delete y del heap manager, es posible que esta memoria no se reutilice, por lo que el uso de p puede seguir funcionando aunque la memoria se haya liberado.

Answer 6

Para agregar un poco a lo que otros han dicho, intente usar una variable miembro de su clase dentro del método check() y luego vea qué sucede.

La función de llamada en el caso de las clases es similar a la función normal llamando a excepción de una pequeña diferencia. Los argumentos se insertan en la pila en ambos casos, pero en el caso de una llamada a función de un objeto, 'this' se coloca en la pila como primer argumento. Este 'esto' se usa dentro de la función para acceder a las variables miembro. Como no está accediendo a ninguna variable miembro, está funcionando. Y sí, puede funcionar incluso si accede a las variables miembro pero obtendrá un comportamiento inesperado porque el compilador puede usar libremente la memoria asignada a 'p'. Tan pronto como el compilador utilizará esa memoria, comenzará a tener bloqueos. Por ejemplo, si declara más variables después de eliminar antes de reutilizar 'p', podría colapsar.

Editar: Además, si su método no está accediendo a ninguna variable miembro, entonces es un candidato definitivo para ser un método estático.

Answer 7

Usted puede hacer lo mismo con los punteros nulos, con tal de que nunca se accede al estado de la instancia de clase:

class object 
{ 
    public: 
    void check() 
    { 
     std::cout<<"I am doing ok..."<<std::endl; 
    } 
}; 

int main() 
{ 
    object *p = 0; 
    p->check(); 
} 

Answer 8

Es aún más divertido que eso. Este compila & corre muy bien:

#include <iostream> 
using namespace std; 
class object { 
    public: 
     void check() { 
      cout << "I am doing ok..." << endl; 
     } 
}; 

int main() { 
    object *p = (object*)0; 
    p->check(); 
    return 0; 
} 

En la shell:

 
$ g++ -o t t.cc 
$ ./t 
I am doing ok... 
$ 

:) En realidad no tiene que tener un objeto para llamar a este método! aplausos, h

Answer 9

1) depende del compilador, en Mac OS con gcc 4.0.1:

g++ -Wall -g -c main.cpp -o main.o 
g++ -o x main.o 
./x 
I am doing ok ... 
I am doing ok ... 
x(5857) malloc: *** error for object 0x100150: double free 
*** set a breakpoint in malloc_error_break to debug 
I am doing ok ... 

problemas gratuitas está causando dobles.

2) Generalmente no se define borrar el puntero que ya se ha eliminado, siempre se debe establecer el puntero en 0 después de eliminar, se permite llamar a eliminar en el puntero con el valor 0.

3) La razón por la que todavía se puede imprimir la cadena es que el puntero aún apunta a la memoria que se liberó, pero supongo que solo se recupera el puntero, p. devuelto al pool libre para su reutilización, la memoria no se sobrescribe o anula, por lo que si desreferencia el puntero, aún obtendrá los valores originales, a menos que la memoria se reutilice mientras tanto.

Answer 10

borrar no establece p a nulo por lo que aún apunta a la ubicación de la memoria. Depende de la implementación de new/delete, pero generalmente elimina solo las marcas de esa parte de la memoria disponible para cualquier asignación nueva.

Es como cuando elimina un archivo de su disco duro. El sistema de archivos simplemente marca esa área como disponible. Los datos del archivo existen y aún se pueden recuperar siempre que no realice nuevas escrituras.