Discussion :

[salseropom]

Bonjour, voici le code suivant :

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
 
#include<stdio.h>
#include<stdlib.h>
 
int main(void)
{
  int * p = malloc(3*sizeof(*p));
  if(p==NULL)
  {
    fprintf(stderr,"erreur\n");
	exit(1);
  }
 
  int * q=p;
 
  free(q); q=NULL;
  //free(p); p=NULL;
 
  printf("c'est fini\n");
  return 0;
}

Si j'enlève la ligne qui est en commentaire, alors mon code tourne jusqu'au bout bien que l'erreur suivante s'affiche sur mon terminal

out(287) malloc: *** error for object 0x5000f0: double free
out(287) malloc: *** set a breakpoint in szone_error to debug
c'est fini

Je comprends tout à fait que la prgm plante car je libère une zone mémoire déjà libérée. Mais pourquoi le prgm s'exécute jusqu'au bout bien qu'il y ait une erreur pendant son exécution ?

Y a-t-il une technique pour remettre le pointeur p à NULL : plus généralement, y a-t-il une manière de structurer les données de telle manière que si je libère une zone de la mémoire, alors tous les pointeurs pointant sur celle-ci se mettent à NULL automatiquement ? Ou dois-je tout faire "à la main" ?

Merci.

[Emmanuel Delahaye]

Y a-t-il une technique pour remettre le pointeur p à NULL : plus généralement, y a-t-il une manière de structurer les données de telle manière que si je libère une zone de la mémoire, alors tous les pointeurs pointant sur celle-ci se mettent à NULL automatiquement ? Ou dois-je tout faire "à la main" ?

Je ne connais que la méthode 'à-la-main', mais il y en a peut être d'autres que je ne connais pas.

Un 'destructeur' peut pas mal faire le ménage,

http://emmanuel-delahaye.developpez.com/tad.htm

mais le pointeur 'ultime' (ou supérieur) devra être forcé à NULL à la main. Je recommande d'ailleurs de le faire avec l'opérateur ',', ce qui rend le code plus 'atomique'...

Code :

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

   xxx_delete(p), p = NULL;

[Sve@r]

Y a-t-il une technique pour remettre le pointeur p à NULL : plus généralement, y a-t-il une manière de structurer les données de telle manière que si je libère une zone de la mémoire, alors tous les pointeurs pointant sur celle-ci se mettent à NULL automatiquement ? Ou dois-je tout faire "à la main" ?

Comme le dit Emmanuel, on initialise toujours les valeurs "à la main" car le C ne fait rien par lui-même. Si t'as plusieurs éléments qui vont ensemble dans une structure, rien ne t'empêche de créer une fonction dédiée à l'initialisation de cette structure que t'appelles quand tu veux.
Mais moi, j'irai même plus loin en disant que quand on gère bien son code, on sait en permanence quand ses pointeurs sont libres et quand ils ne le sont pas ce qui fait que les mettre à NULL devient inutile...

[salseropom]

Comme le dit Emmanuel, on initialise toujours les valeurs "à la main" car le C ne fait rien par lui-même. Si t'as plusieurs éléments qui vont ensemble dans une structure, rien ne t'empêche de créer une fonction dédiée à l'initialisation de cette structure que t'appelles quand tu veux.
Mais moi, j'irai même plus loin en disant que quand on gère bien son code, on sait en permanence quand ses pointeurs sont libres et quand ils ne le sont pas ce qui fait que les mettre à NULL devient inutile...

Bonjour,
je fais bien des "constructeurs" et des "destructeurs" dès que je crée une structure. Ca fait qqch du genre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
T * CreateT(blabla)
{
  T * t=malloc(sizeof(*T));
  if(==NULL) /* erreur */
  blabla;
}
 
void DestroyT(T ** t)
{
  /* ici je détruits tous les champs (*t)-> et je les remets à NULL*/
  free(*t); *t=NULL;
}

Ca revient un peu à faire ce que m'a dit Emmanuel.

Mais ma question porte sur l'exemple suivant :

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
29
30
31
32
33
34
35
36
 
typedef struct
{
  double a;b;
} S1;
 
S1 * CreateS1(void)
{
  S1 * s1=malloc(sizeof(*s1));
  if(s1==NULL) /* erreur */
  return s1;
}
 
void DestroyS1(S1 ** s1)
{
  free(*s1); *s1=NULL;
}
 
typedef struct
{
  double a,b,c;
  S1 * s1;
} S2;
 
S2 * CreateS2(S1 * s1)
{
  S2 * s2=malloc(sizeof(*s2));
  if(s2==NULL) /* erreur */
  s2->s1=s1; /* ici copie de pointeur */  
  return s1;
}
 
void DestroyS2(S2 ** s2)
{
  free(*s2); *s2=NULL;
}

donc quand je fais un DestroyS2 et un DestroyS1, mon pointeur s2->s1 ne vaut pas NULL (mais s2 vaut NULL).

D'où ma question : y a-t-il une technique pour mettre s2->s1 à NULL ? En vous lisant, c'est "à la main", ce que je pensais. Mais c'est un peu "galère" tout de même non ?

[Sve@r]

Bonjour,
je fais bien des "constructeurs" et des "destructeurs" dès que je crée une structure.

Oui, tu entres dans la technologie objet => c'est une bonne initiative...

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
typedef struct
{
  double a,b,c;
  S1 * s1;
} S2;
 
S2 * CreateS2(S1 * s1)
{
  S2 * s2=malloc(sizeof(*s2));
  if(s2==NULL) /* erreur */
  s2->s1=s1; /* ici copie de pointeur */  
  return s1;
}
 
void DestroyS2(S2 ** s2)
{
  free(*s2); *s2=NULL;
}

donc quand je fais un DestroyS2 et un DestroyS1, mon pointeur s2->s1 ne vaut pas NULL (mais s2 vaut NULL).
D'où ma question : y a-t-il une technique pour mettre s2->s1 à NULL ? En vous lisant, c'est "à la main", ce que je pensais. Mais c'est un peu "galère" tout de même non ?

Ben rien ne t'empêche, dans DestroyS2, d'appeler d'abord DestroyS1...
Et bien entendu, fidèle à mon opinion, pour moi mettre les pointeurs à NULL reste inutile...

Petit bug => Ta fonction CreateS2 de type S2* renvoie s1 qui est de type S1*...

[Zartan]

Il y a des techniques (garbage collector, ramasse-miettes en français) mais c'est assez lourd, il faut une liste chainée de tout ce qui référence votre pointeur, donc des fonctions d'allocation, de libération et d'affectation spéciales.

[nicolas.sitbon]

En poussant un peu plus loin ça doit être faisable, un début peut être :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
typedef struct
{
  double a, b;
} S1;
 
S1 * CreateS1(void)
{
  S1 * s1=malloc(sizeof *s1);
  if(s1 != NULL)
  {
    s1->a = s1->b = 0.0;
  }
  return s1;
}
 
void DestroyS1(S1 ** s1)
{
  if((s1 != NULL) && (*s1 != NULL))/* simple vérif */
  {
    free(*s1), *s1=NULL;
  }
}
 
typedef struct
{
  double a,b,c;
  S1 * s1;
} S2;
 
S2 * CreateS2(S1 * s1)
{
  S2 * s2=malloc(sizeof *s2);
  if(s2 != NULL)
  {
    s2->a = s2->b = s2->c = 0.0;
    if(s1 != NULL)
    {
      s2->s1 = s1
    }
    else
    {
      s2->s1 = CreateS1();
    }
  }
  return s2;
}
 
void DestroyS2(S2 ** s2)
{
  if((s2 != NULL) && (*s2 != NULL))/* simple vérif */
  {
    if((*s2)->s1 != NULL)
    {
      DestroyS1(&(*s2)->s1);
    }
    free(*s2), *s2=NULL;
  }
}

[salseropom]

Oui, tu entres dans la technologie objet => c'est une bonne initiative...



Ben rien ne t'empêche, dans DestroyS2, d'appeler d'abord DestroyS1...
Et bien entendu, fidèle à mon opinion, pour moi mettre les pointeurs à NULL reste inutile...

Petit bug => Ta fonction CreateS2 de type S2* renvoie s1 qui est de type S1*...

tout à fait, erreur de copier-coller.

[Emmanuel Delahaye]

Comme le dit Emmanuel, on initialise toujours les valeurs "à la main" car le C ne fait rien par lui-même. Si t'as plusieurs éléments qui vont ensemble dans une structure, rien ne t'empêche de créer une fonction dédiée à l'initialisation de cette structure que t'appelles quand tu veux.
Mais moi, j'irai même plus loin en disant que quand on gère bien son code, on sait en permanence quand ses pointeurs sont libres et quand ils ne le sont pas ce qui fait que les mettre à NULL devient inutile...

Euh, non, ce n'est pas si simple. Il y a des cas de 'send-and-forget', notamment en multi-tâche, où la tâche qui crée l'objet n'est pas celle qui le détruit...
(pseudo-C)

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
 
/* task A */
 
{
   xxx *p = xxx_create();
 
   /* traitement */
 
   err = envoyer (B, p); /* send ... */
   if (err)
   {
      xxx_delete(p);
   }
   p = NULL; /* and forget */
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* task B */
{
   xxx *p = NULL;
   err = recevoir (&p);
 
   if (!err)
   {
       /* traitement */
 
       xxx_delete(p), p = NULL;
   }
}

[Emmanuel Delahaye]

Bonjour,
je fais bien des "constructeurs" et des "destructeurs" dès que je crée une structure. Ca fait qqch du genre

Oui : http://emmanuel-delahaye.developpez.com/tad.htm

[souviron34]

Mais moi, j'irai même plus loin en disant que quand on gère bien son code, on sait en permanence quand ses pointeurs sont libres et quand ils ne le sont pas ce qui fait que les mettre à NULL devient inutile...

Non je suis d'accord avec Emmanuel.

Il est des cas où (par exemple dans un programme par événements, et/ou en temps réel), on ne sait pas quand les pointeurs sont libres (exemple : si tu fais une liste chainée, ça n'est pas pour rajouter un compteur à coté.. Il faut bien tester si l'élément est NULL ou non).

[salseropom]

Oui : http://emmanuel-delahaye.developpez.com/tad.htm

oui, normalement, j'ai fait ce qui est marqué dans tes TAD. D'ailleurs, cela m'a permis de modifier ma classe de matrice (au lieu de faire N+1 allocations, je n'en faisais plus que 2) sans modifier mon "interface")

Sinon, d'après souviron 34, Emmanuel et Sve@r, j'en déduis que pour remettre TOUS mes pointeurs à NULL (je pense notamment à mes structures temporaires dans lesquelles je fais des copies de pointeurs (et non pas des copies de structures) pour accélérer mon code) je suis obligé de retrousser mes manches et de tout faire "à la main".