Pregunta Diferencia entre el puntero colgante y la 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?


73
2017-10-30 04:48


origen


Respuestas:


UN puntero colgando apunta a la memoria que ya ha sido liberada. El almacenamiento ya no está asignado. Intentar acceder a él podría causar un error de segmentación.

Forma 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 alcance antes de que el control se devolviera 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 de un puntero, después de haber sido liberado explícitamente invocó ese recuerdo.

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

UN pérdida de memoria es memoria que no ha sido liberada, no hay forma de acceder (o liberarla) ahora, ya que no hay formas de llegar a ella nunca más. (Por ejemplo, un puntero que estaba la única referencia a una ubicación de memoria asignado dinámicamente (y no liberado) que apunta a otro lado 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 sale del alcance al final de la función, filtrando los dinámicamente asignados 10 bytes.


131
2017-10-30 04:49



Puedes pensar en estos como los opuestos el uno del otro.

Cuando libera un área de memoria, pero aún mantiene un puntero al mismo, 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!

20
2017-10-30 04:54



UN puntero colgando es uno que tiene un valor (no NULO) que se refiere a alguna memoria que no es válida para el tipo de objeto que espera. Por ejemplo, si configura un puntero a un objeto, sobrescriba esa memoria con algo que no esté relacionado o libere la memoria si se asignó dinámicamente.

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

Se relacionan en que 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 hayas liberado la memoria, pero luego trataste de referenciarla; en el otro (fuga de memoria), ¡ha olvidado liberar la memoria por completo!


13
2017-10-30 04:50



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. Tal puntero es conocido como puntero colgando 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

Nota: en algunos compiladores, puede recibir una dirección de devolución de mensaje de advertencia   de variable local o temporal

Explicación: 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.

Solución de este problema: hacer que la variable x sea una variable estática. En otras palabras, podemos decir que un puntero cuyo objeto de puntería ha sido eliminado se llama puntero colgante.

Pérdida de memoria

En informática, se produce una pérdida de memoria cuando un programa de computadora administra incorrectamente las asignaciones de memoria. Como simple, hemos asignado la memoria y no el término de otro idioma libre, digamos que no lo liberamos, llame a la pérdida de memoria, es fatal para la aplicación y falla inesperada.


6
2017-07-19 06:32



El puntero ayuda a crear el alcance definido por el usuario a una variable, que se llama variable dinámica. La variable dinámica puede ser una sola variable o un grupo de variable del mismo tipo (array) o grupo de variables de diferentes tipos (struct) El alcance de la variable local predeterminada se inicia 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 sostiene mediante un puntero puede comenzar y finalizar en cualquier punto de la ejecución de un programa, que debe ser decidido por un programador. Las pérdidas de memoria y colgantes se visualizan solo si un programador no maneja el final del alcance.

La pérdida de memoria ocurrirá si un programador no escribe el código (free de puntero) para el final del alcance de las variables dinámicas. De cualquier forma una vez que el programa salga de 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 está funcionando mucho tiempo.

Una vez que el alcance 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. Entonces, el puntero colgante no es más que un puntero que señala una variable dinámica cuyo alcance ya está terminado.


3
2017-07-19 06:56



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

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

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

myarea=newarea;

Puntero colgante: Cuando una variable de puntero en una pila pero sin memoria en el montón.

char *p =NULL;

Un puntero colgante que intenta desreferencia sin asignar espacio dará como resultado un error de segmentación.


3
2017-07-28 19:06



Un puntero que apunta a una ubicación de memoria que se ha eliminado (o liberado) se denomina 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Í


0
2017-07-03 13:59