Différence entre le pointeur pendant et la fuite de mémoire
Je ne comprends pas la différence entre un pointeur suspendu et une fuite de mémoire. Comment ces deux termes sont-ils liés?
Un pointeur suspendu pointe vers la mémoire déjà libérée. Le stockage n'est plus alloué. Essayer d'y accéder peut provoquer une erreur de segmentation.
Manière courante de se retrouver avec un pointeur en suspens:
char* func()
{
char str[10];
strcpy(str,"Hello!");
return(str);
}
//returned pointer points to str which has gone out of scope.
Vous retournez une adresse qui était une variable locale et qui aurait été hors de portée lorsque le contrôle a été renvoyé à la fonction appelante. (Comportement indéfini)
Un autre exemple courant de pointeur en suspens est l’accès d’un emplacement mémoire via un pointeur, après que le nom free a été appelé explicitement sur cette mémoire.
int *c = malloc(sizeof(int));
free(c);
*c = 3; //writing to freed location!
Une fuite de mémoire est une mémoire qui n'a pas été libérée. Il n'y a aucun moyen d'accéder (ou de le libérer) maintenant, car il n'y a plus aucun moyen d'y accéder. (Par exemple, un pointeur qui était la seule référence à un emplacement mémoire alloué dynamiquement (et non libéré) qui pointe ailleurs maintenant.)
void func(){
char *ch;
ch = (char*) malloc(10);
}
//ch not valid outside, no way to access malloc-ed memory
Char-ptr ch est une variable locale qui sort de la portée à la fin de la fonction, laissant filtrer 10 octets alloués dynamiquement.
Vous pouvez les considérer comme les opposés les uns des autres.
Lorsque vous libérez une zone de mémoire tout en gardant un pointeur dessus, ce pointeur est suspendu:
char *c = malloc(16);
free(c);
c[1] = 'a'; //invalid access through dangling pointer!
Lorsque vous perdez le pointeur tout en maintenant la mémoire allouée, vous avez une fuite de mémoire:
void myfunc()
{
char *c = malloc(16);
} //after myfunc returns, the the memory pointed to by c is not freed: leak!
Un pointeur dangling est un pointeur ayant une valeur (pas NULL) qui fait référence à une mémoire non valide pour le type d'objet que vous attendez. Par exemple, si vous définissez un pointeur sur un objet, vous écrasez cette mémoire par une autre information non liée ou libérez la mémoire si elle était allouée de manière dynamique.
Une fuite de mémoire se produit lorsque vous allouez de manière dynamique de la mémoire à partir du tas, mais que vous ne la libérez jamais, peut-être parce que vous avez perdu toutes ses références.
Ils sont liés en ce qu'ils sont tous deux des situations relatives à des pointeurs mal gérés, en particulier en ce qui concerne la mémoire allouée dynamiquement. Dans une situation (pointeur en suspens), vous avez probablement libéré la mémoire mais essayé de la référencer par la suite; dans l'autre (fuite de mémoire), vous avez oublié de libérer entièrement la mémoire!
Pointeur suspendu
Si un pointeur pointe l'adresse mémoire d'une variable, mais après qu'une variable a été supprimée de cet emplacement mémoire, alors que le pointeur pointe toujours cet emplacement mémoire. Un tel pointeur est appelé pointeur pointeur et ce problème est appelé problème de pointeur pointeur.
#include<stdio.h>
int *call();
void main(){
int *ptr;
ptr=call();
fflush(stdin);
printf("%d",*ptr);
}
int * call(){
int x=25;
++x;
return &x;
}
Sortie: valeur de garbage
Remarque: Dans certains compilateurs, vous pouvez obtenir un message d'avertissement indiquant l'adresse de retour de variable locale ou temporaire
Explication: la variable x est une variable locale. Sa portée et sa durée de vie se situent dans l'appel de la fonction. Par conséquent, après que l'adresse retournée de la variable x soit devenue morte et que le pointeur est toujours pointé, ptr pointe toujours vers cet emplacement.
Solution de ce problème: Définissez la variable x comme variable statique . Dans Word, nous pouvons dire qu'un pointeur dont l'objet de pointage a été supprimé s'appelle un pointeur suspendu.
Fuite de mémoire
En informatique, une fuite de mémoire se produit lorsqu'un programme informatique gère de manière incorrecte les affectations de mémoire . Comme par simple moyen, nous avons alloué la mémoire et non un autre terme de langage libre ne le lâchez pas.
Le pointeur permet de créer une portée définie par l'utilisateur pour une variable, appelée variable dynamique. La variable dynamique peut être une variable unique ou un groupe de variables du même type (array) ou un groupe de variables de types différents (struct). La portée de la variable locale par défaut commence lorsque le contrôle entre dans une fonction et se termine lorsque le contrôle sort de cette fonction. La portée globale vairable par défaut commence à l'exécution du programme et se termine à la fin du programme.
Mais la portée d'une variable dynamique qui tient par un pointeur peut commencer et se terminer à n'importe quel moment de l'exécution d'un programme, ce qui doit être décidé par un programmeur. Une fuite de mémoire et une perte de mémoire n'interviennent dans l'image que si un programmeur ne gère pas la fin de la portée.
Une fuite de mémoire surviendra si un programmeur n'écrit pas le code (free du pointeur) pour la fin de la portée des variables dynamiques. Une fois le programme terminé, la mémoire de processus perdue sera libérée. À ce moment, la mémoire perdue sera également libérée. Mais cela causera un très grave problème pour un processus qui dure longtemps.
Une fois que la portée de la variable dynamique arrive à la fin (libérée), NULL doit être affecté à la variable de pointeur. Sinon, si le code y accède à tort, un comportement indéfini se produira. Ainsi, le pointeur en suspens n’est autre qu’un pointeur qui pointe une variable dynamique dont la portée est déjà terminée.
Fuite de mémoire : Lorsqu'il existe une zone mémoire dans un segment de mémoire mais aucune variable dans la pile pointant vers cette mémoire.
char *myarea=(char *)malloc(10);
char *newarea=(char *)malloc(10);
myarea=newarea;
Pointeur suspendu : Quand une variable de pointeur dans une pile mais pas de mémoire dans le tas.
char *p =NULL;
Un pointeur suspendu essayant de déréférencer la référence sans allouer d'espace entraînera une erreur de segmentation.
Un pointeur pointant vers un emplacement mémoire supprimé (ou libéré) est appelé pointeur suspendu.
#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);
}
pour plus d'informations, cliquez ICI
Un pointeur pointant vers un emplacement mémoire supprimé (ou libéré) est appelé pointeur suspendu. Il existe trois manières différentes pour lesquelles Pointer agit en tant que pointeur suspendu.
- Désaffectation de mémoire
- Appel de fonction
- La variable sort du cadre
—— de https://www.geeksforgeeks.org/dangling-void-null-wild-pointers/