Discussion :

[icer]

Bonjour,

J'aimerais savoir si la libération de mémoire avec un pointeur autre que celui qui a été utilisé pour l'allocation peut poser des problèmes?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <stdlib.h>
int main(){
 
    int * a;
    int * b;
 
    a = malloc(size(int));
    b = a;
 
    free(b);
}

Est-ce que la mémoire est correctement libérée de cette manière ?

[crocodilex]

Oui, la mémoire sera correctement libérée, puisque c'est le même pointeur....

[icer]

La même adresse tu veux dire...

Ce qui signifie que seul l'adresse de la mémoire est suffisant pour l'OS pour retrouver la zone réservée. Et donc que la taille de cette zone a été mémoriser par l'OS au moment de l'allocation.

[souviron34]

oui

par contre pas propre du tout...

[icer]

par contre pas propre du tout...

pourquoi pas ?

[souviron34]

entraine une illisibilité, c'est dangereux, c'est tout..

Si on alloue une varaible, pourquoi ne pas la libérer ELLE ?

[Thierry Chappuis]

Dans tous les cas, il est recommandé d'affecter la valeur NULL à b et à a après la libération, ce qui explicite le fait qu'ils contiennent une adresse invalide.

Thierry

[icer]

Si on alloue une varaible, pourquoi ne pas la libérer ELLE ?

On pourrais, par exemple, avoir besoin d'une fonction qui se charge d'allouer une zone mémoire et de retourner un pointeur sur cette zone.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char * c = new_char();

Dans ce cas on n'a pas accès au pointeur qui servit à l'allocation, puisqu'il est caché dans la fonction.

[Franck.H]

Si on alloue une varaible, pourquoi ne pas la libérer ELLE ?

Bin comme l'a démontré icer, si tu fait une allocation d'un objet par le biais d'un constructeur, tu retournes l'adresse de l'objet, tu n'as donc plus accés au pointeur d'origine, l'essentiel est donc d'avoir l'adresse qui elle ne change pas d'un pointeur à un autre lorsqu'il s'agit du même objet.

[DaZumba]

Dans ce cas on n'a pas accès au pointeur qui servit à l'allocation, puisqu'il est caché dans la fonction.

Il n'est pas cache, il n'existe plus lorsque la fonction retourne. Il ne faut pas confondre une variable et sa valeur. malloc() retourne l'adresse du debut du bloc alloue, et on stocke cette adresse dans une variable speciale concue pour stocker des adresses. Cette variable speciale s'appelle un pointeur.
Evidemment, on peut copier cette adresse et la stocker dans d'autres pointeurs. Si plusieurs pointeurs existent en meme temps avec une meme valeur (une adresse donc, si tu as suivi), et si cette valeur devient invalide (par exemple si le bloc alloue est libere), alors tous ces pointeurs deviennent inutilisables.

[Pierre Maurette]

Je pense depuis longtemps qu'un chapitre sur l'allocation mémoire devrait écrire en gras et très tôt "La valeur [ = valeur numérique] renvoyée par malloc() est la seule clé permettant d'accéder à la mémoire allouée, et de la libérer".

Ce qui est fait dans le programme et dans l'OS dépend de l'OS, qui peut aller jusquà proposer directement les fonctions du C. Mais peu importe. Il suffit de savoir, ou plutôt d'imaginer que "tout passe comme si", que le pointeur renvoyé est un vrai pointeur pour l'accès mémoire, et une clé dans une table permettant d'accéder à un objet descripteur.

Vous avez tout à fait raison de souligner que quand vous écrivez une fonction qui retourne un pointeur qui doit être libéré par l'appelant, vous avez une copie de la valeur retournée par malloc() dans une variable locale de la fonction, puis une copie de cette valeur dans une variable de l'appelant - sans parler de la virtuelle "variable invisible de transport", un registre par exemple.

Vous pouvez également avoir plusieurs copies de cette valeur, par exemple une pour l'utilisation, et une autre dans un tableau contenant les [valeurs des] pointeurs à libérer.

[Emmanuel Delahaye]

Je pense depuis longtemps qu'un chapitre sur l'allocation mémoire devrait écrire en gras et très tôt "La valeur [ = valeur numérique] renvoyée par malloc() est la seule clé permettant d'accéder à la mémoire allouée, et de la libérer".

Oui, et je crois que pour en terminer définitivement avec les erreurs, cette valeur doit être nommée correctement, c'est à dire 'adresse' et non 'pointeur' comme on le voit trop souvent, à commencer par cette discussion qui fait allègrement la confusion entre les deux, entretenant les erreurs de compréhension et la question originale elle même.

Enfin, on ne 'libère pas de pointeur'. On libère le bloc mémoire dont l'adresse est contenue dans tel ou tel pointeur...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
   T *p = malloc();
   T *q = p; /* aliasing */
   <...>
 
   free (q);

est dont tout à fait valide. Bien sûr, l'aliasing est peu recommandé, mais il est techniquement possible. Le bon sens élémentaire recommande que tous les pointeurs concernés soient remis à NULL après libération du bloc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
    p = NULL;
    q = NULL;

Une technique d'aliasing propre consiste à 'refiler le bébé' :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
   T *q = p; /* aliasing */
    p = NULL;

Evidemment, du code comme ceci n'existe probablement pas dans la vraie vie, par contre ceci, oui :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
{
   MSG *m = msg_create("Hello world");
   int try = 0;
 
   int err;
   do
   {
      err  = xmit (m); /* Libère m quand l'émission réelle est terminée.
                               Ca pourrait être dans une autre tâche... */
      if (!err)
      {
         m = NULL;
      }
      else
      {
         try++;
      }
   }
   while (err && count < 3);
 
   if (err)
   {
      msg_delete (m);
      m=NULL;
      puts("fatal error");
   }
}