¿Qué es una referencia colgante?

Sé que esta es una pregunta bastante común, ¡pero aún nueva para mí!

No entiendo el concepto de puntero colgante, busqué en Google y escribí métodos de prueba para encontrar uno … Me pregunto si este es un puntero colgante. Como cualquier ejemplo que encontré fue devolver algo, ¡aquí estoy intentando algo similar! ¡Gracias!

void foo(const std::string name) { new_foo(name.c_str()); ///// will it be Dangling pointer?!, with comments/Answer ///// it could be if in new_foo, I store name into Global. ///// Why?! And what is safe then? } void new_foo(const char* name) { ... print name or do something with name... } 

Un puntero colgante es un puntero que apunta a datos no válidos o a datos que ya no son válidos, por ejemplo:

 Class *object = new Class(); Class *object2 = object; delete object; object = nullptr; // now object2 points to something which is not valid anymore 

Esto puede ocurrir incluso en objetos asignados de stack:

 Object *method() { Object object; return &object; } Object *object2 = method(); // object2 points to an object which has been removed from stack after exiting the function 

El puntero devuelto por c_str puede c_str ser válido si la cadena se modifica posteriormente o se destruye. En su ejemplo, parece que no lo modifica, pero como no está claro qué va a hacer con const char *name , es imposible saber si su código es intrínsecamente seguro o no.

Por ejemplo, si almacena el puntero en algún lugar y luego se destruye la cadena correspondiente, el puntero deja de ser válido. Si usa const char *name solo en el ámbito de new_foo (por ejemplo, para fines de impresión), el puntero seguirá siendo válido.

Un puntero colgante es un puntero (no nulo) que apunta al área de memoria no asignada (ya liberada).

El ejemplo anterior debe ser correcto dado que la cadena no se modifica a través de new_foo.

Como cuestión de estilo, explico un puntero colgante como “un puntero que aún existe, aunque el objeto al que apunta ya no existe”.

En su caso, el name del puntero existe por un período más corto que el objeto al que apunta. Entonces nunca está colgando.

Dentro de las clases comunes de C ++, los punteros cuelgan por un período muy corto, dentro de los destructores. Eso es porque la instrucción delete está antes del último } del destructor, mientras que el puntero deja de existir en el último } . Si no desea preocuparse por esto, use eg unique_ptr . El puntero T* colgará por muy poco tiempo dentro del unique_ptr::~unique_ptr , que es perfectamente seguro.

Tomado de aquí . Aunque, incluso si esto es para C, es lo mismo para C ++.

Puntero colgante

Si algún puntero señala la dirección de memoria de cualquier variable, pero después de que alguna variable haya eliminado de esa ubicación de memoria, mientras el puntero aún esté apuntando a dicha ubicación de memoria. Dicho puntero se conoce como puntero colgante y este problema se conoce como problema de puntero colgante.

Inicialmente

enter image description here

Luego

enter image description here

Ejemplo

 #include int *call(); int main(){ int *ptr; ptr=call(); fflush(stdin); printf("%d",*ptr); return 0; } int * call(){ int x=25; ++x; return &x; } 

Su salida será basura porque la variable x es una variable local. Su scope y duración está dentro de la llamada de función, por lo tanto, después de devolver la dirección de la variable x x se volvió muerta y el puntero sigue apuntando, ptr aún apunta a esa ubicación.

Puntero colgante y problema de puntero colgante Si algún puntero señala la dirección de memoria de cualquier variable pero después de que alguna variable haya eliminado de esa ubicación de memoria mientras el puntero aún apunta a dicha ubicación de memoria.

Ese puntero se denomina puntero colgante y el problema que surge en ese momento se denomina problema de puntero colgante.

Aquí hay algunos ejemplos: Puntero colgante y problema con el puntero colgando