Diferencia entre puntero colgante y pérdida de memoria.

No entiendo la diferencia entre un puntero colgante y una pérdida de memoria. ¿Cómo se relacionan estos dos términos?

Un puntero colgante apunta a la memoria que ya se ha liberado. El almacenamiento ya no está asignado. Intentar acceder a él puede causar un fallo de segmentación.

Manera común de terminar con un puntero colgante:

char* func() { char str[10]; strcpy(str,"Hello!"); return(str); } //returned pointer points to str which has gone out of scope. 

Está devolviendo una dirección que era una variable local, que se habría salido del scope en el momento en que se devolvió el control a la función de llamada. (Comportamiento indefinido)

Otro ejemplo común de puntero colgante es el acceso a una ubicación de memoria a través del puntero, después de que se haya llamado explícitamente a free en esa memoria.

 int *c = malloc(sizeof(int)); free(c); *c = 3; //writing to freed location! 

Una pérdida de memoria es una memoria que no se ha liberado, no hay forma de acceder (o liberarla) ahora, ya que no hay manera de acceder a ella. (Por ejemplo, un puntero que era la única referencia a una ubicación de memoria asignada dinámicamente (y no liberada) que apunta a otro lugar ahora).

 void func(){ char *ch; ch = (char*) malloc(10); } //ch not valid outside, no way to access malloc-ed memory 

Char-ptr ch es una variable local que se sale del scope al final de la función y pierde los 10 bytes asignados dinámicamente.

Usted puede pensar en estos como los opuestos entre sí.

Cuando liberas un área de memoria, pero aún mantienes un puntero hacia ella, ese puntero está colgando:

 char *c = malloc(16); free(c); c[1] = 'a'; //invalid access through dangling pointer! 

Cuando pierde el puntero, pero mantiene la memoria asignada, tiene una pérdida de memoria:

 void myfunc() { char *c = malloc(16); } //after myfunc returns, the the memory pointed to by c is not freed: leak! 

Un puntero colgante es uno que tiene un valor (no NULL) que se refiere a alguna memoria que no es válida para el tipo de objeto que espera. Por ejemplo, si establece un puntero a un objeto, sobrescribe esa memoria con otra cosa no relacionada o libera la memoria si se asignó dinámicamente.

Una pérdida de memoria es cuando asigna dinámicamente memoria del montón pero nunca la libera, posiblemente porque perdió todas las referencias a ella.

Se relacionan porque ambas son situaciones relacionadas con punteros mal administrados, especialmente con respecto a la memoria asignada dinámicamente. En una situación (puntero colgante) es probable que haya liberado la memoria pero haya intentado hacer referencia a ella posteriormente; en la otra (pérdida de memoria), se ha olvidado de liberar la memoria por completo!

Puntero que cuelga

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

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

Salida: valor de basura

Nota: en algunos comstackdores puede recibir un mensaje de advertencia que devuelve la dirección de la variable local o temporal

Explicación: la variable x es una variable local. Su scope y duración está dentro de la llamada de la función, por lo tanto, después de devolver la dirección de x la variable x está muerta y el puntero sigue apuntando, ptr sigue apuntando a esa ubicación.

Solución de este problema: Hacer que la variable x sea como variable estática. En otras palabras, podemos decir que un puntero cuyo objeto señalador ha sido eliminado se llama puntero colgante.

Pérdida de memoria

En informática, se produce una pérdida de memoria cuando un progtwig de computadora administra incorrectamente las asignaciones de memoria. Según lo simple, hemos asignado la memoria y no otro término en otro idioma, digamos, no liberarlo, la pérdida de memoria de llamada es fatal para la aplicación y un fallo inesperado.

El puntero ayuda a crear un ámbito definido por el usuario para una variable, que se denomina variable dinámica. Variable dinámica puede ser una sola variable o un grupo de variables del mismo tipo ( array ) o un grupo de variables de diferentes tipos ( struct ). El scope de la variable local predeterminada comienza cuando el control entra en una función y termina cuando el control sale de esa función. El scope global predeterminado de vairable comienza en la ejecución del progtwig y finaliza una vez que el progtwig finaliza.

Pero el scope de una variable dinámica que se mantiene mediante un puntero puede comenzar y finalizar en cualquier punto de la ejecución de un progtwig, lo que debe ser decidido por un progtwigdor. La fuga y la pérdida de memoria aparecen en la imagen solo si un progtwigdor no maneja el final del scope.

Se producirá una pérdida de memoria si un progtwigdor no escribe el código ( free puntero) para el final del scope de las variables dinámicas. De cualquier manera, una vez que el progtwig sale, se liberará la memoria del proceso completo, en ese momento también se liberará esta memoria filtrada. Pero causará un problema muy serio para un proceso que se está ejecutando durante mucho tiempo.

Una vez que el scope de la variable dinámica llega a su fin (liberado), NULL debe asignarse a la variable de puntero. De lo contrario, si el código accede erróneamente, se producirá un comportamiento indefinido. Por lo tanto, el puntero colgante no es más que un puntero que apunta a una variable dinámica cuyo scope ya está terminado.

Pérdida de memoria : cuando hay un área de memoria en un montón pero ninguna variable en la stack apunta a esa memoria.

 char *myarea=(char *)malloc(10); char *newarea=(char *)malloc(10); myarea=newarea; 

Puntero colgante : cuando una variable puntero está en una stack pero no hay memoria en el montón.

 char *p =NULL; 

Un puntero colgante que intenta eliminar la referencia sin asignar espacio dará como resultado una falla de segmentación.

Un puntero que apunta a una ubicación de memoria que se ha eliminado (o liberado) se llama puntero colgante.

 #include  #include  void main() { int *ptr = (int *)malloc(sizeof(int)); // After below free call, ptr becomes a // dangling pointer free(ptr); } 

para mas informacion haga click AQUI

Un puntero que apunta a una ubicación de memoria que se ha eliminado (o liberado) se llama puntero colgante. Hay tres formas diferentes en las que Pointer actúa como puntero colgante. 1.De-la asignación de memoria 2.La llamada funcional 3.La variable está fuera del scope Siga la siguiente URL para obtener detalles https://www.geeksforgeeks.org/dangling-void-null-wild-pointers/