No entiendo la diferencia entre un puntero colgante y una pérdida de memoria. ¿Cómo se relacionan estos dos términos?
79
Un puntero colgante apunta a una memoria que ya se ha liberado. El almacenamiento ya no está asignado. Intentar acceder a él puede provocar una falla de segmentación.
Forma común de terminar con un puntero colgando:
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 habría salido del alcance 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 un acceso a una ubicación de memoria a través de un 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 fuga de memoria es memoria que no se ha liberado, no hay forma de acceder (o liberar) ahora, ya que no hay forma 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 = malloc(10);
}
//ch not valid outside, no way to access malloc-ed memory
Char-ptr ch es una variable local que sale del alcance al final de la función, filtrando los 10 bytes asignados dinámicamente .
Puede pensar en estos como opuestos entre sí.
Cuando libera un área de memoria, pero aún mantiene 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!fuente
Un puntero colgante es aquel que tiene un valor (no NULL) que se refiere a una memoria que no es válida para el tipo de objeto que espera. Por ejemplo, si establece un puntero a un objeto, sobrescriba esa memoria con algo más no relacionado o liberó la memoria si se asignó dinámicamente.
Una fuga de memoria es cuando asigna memoria de forma dinámica desde el montón pero nunca la libera, posiblemente porque perdió todas las referencias a ella.
Están relacionados en el sentido de que ambas son situaciones relacionadas con punteros mal administrados, especialmente con respecto a la memoria asignada dinámicamente. En una situación (puntero colgante) probablemente haya liberado la memoria, pero intentado hacer referencia a ella después; en el otro (pérdida de memoria), ¡se ha olvidado de liberar la memoria por completo!
fuente
Puntero colgante
Si algún puntero apunta a la dirección de memoria de cualquier variable pero después de que alguna variable se haya borrado de esa ubicación de memoria mientras el puntero sigue apuntando a dicha ubicación de memoria. Dicho puntero se conoce como puntero colgante y este problema se conoce como problema de puntero colgante.
#include<stdio.h> 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
Explicación: la variable x es una variable local. Su alcance y vida útil están dentro de la llamada a la función, por lo tanto, después de devolver la dirección de x, la variable x se volvió inactiva y el puntero sigue apuntando, ptr todavía apunta a esa ubicación.
Solución de este problema: Haga que la variable x sea una 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 programa informático gestiona incorrectamente las asignaciones de memoria. Según el simple, hemos asignado la memoria y no el término libre en otro idioma, digamos que no lo libere, llame a la pérdida de memoria, es fatal para la aplicación y un bloqueo inesperado.
fuente
El puntero ayuda a crear un alcance definido por el usuario para una variable, que se denomina variable dinámica. La 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 alcance de la variable local predeterminada comienza cuando el control entra en una función y finaliza cuando el control sale de esa función. El alcance variable global predeterminado comienza en la ejecución del programa y finaliza una vez que finaliza el programa.Pero el alcance de una variable dinámica que se mantiene mediante un puntero puede comenzar y terminar en cualquier punto de la ejecución de un programa, lo cual debe ser decidido por un programador. La pérdida de memoria y la pérdida de memoria entran en escena solo si un programador no maneja el final del alcance.
Se producirá una pérdida de memoria si un programador no escribe el código (
freedel puntero) para el fin del alcance de las variables dinámicas. De cualquier forma, una vez que el programa salga, la memoria de proceso completa se liberará, en ese momento esta memoria filtrada también se liberará. Pero causará un problema muy serio para un proceso que se está ejecutando durante mucho tiempo.Una vez que el alcance de la variable dinámica llega a su fin (liberado),
NULLdebe asignarse a la variable de puntero. De lo contrario, si el código accede de forma incorrecta, se producirá un comportamiento indefinido. Entonces, el puntero colgante no es más que un puntero que apunta a una variable dinámica cuyo alcance ya está terminado.fuente
Pérdida de memoria : cuando hay un área de memoria en un montón pero ninguna variable en la pila apunta a esa memoria.
char *myarea=(char *)malloc(10); char *newarea=(char *)malloc(10); myarea=newarea;Puntero colgante : cuando una variable de puntero está en una pila pero no hay memoria en el montón.
char *p =NULL;Un puntero colgante que intente desreferenciar sin asignar espacio resultará en una falla de segmentación.
fuente
Un puntero que apunta a una ubicación de la memoria que se ha eliminado (o liberado) se llama puntero colgante.
#include <stdlib.h> #include <stdio.h> void main() { int *ptr = (int *)malloc(sizeof(int)); // After below free call, ptr becomes a // dangling pointer free(ptr); }para más información haga clic AQUÍ
fuente
—— de https://www.geeksforgeeks.org/dangling-void-null-wild-pointers/
fuente