c++ - ¿Qué es una referencia colgante?

dangling-pointer

Question

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...   
}

Answer 1

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<T> . El puntero T* colgará por muy poco tiempo dentro del unique_ptr::~unique_ptr , que es perfectamente seguro.

Answer 2

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

Answer 3

Tomado de here . 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

Luego

Ejemplo

#include<stdio.h>

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 alcance 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.

Answer 4

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.

Answer 5

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 pila:

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.