gestion mémoire sur plusieurs malloc

**contremaitre** · 21/02/2008, 17h05

Bonjour,

Je voudrais savoir si vous avez des methodes pour gérer les malloc et leurs tests si ils echouent.

Voici un exemple que j'ai écrit pour 3 pointeurs a allouer. Il me semble que ce code est "sur" dans le sens ou on ne peut pas perdre de mémoire, mais on voit que ca peut devenir vite lourd à gerer, surtout si on en a plus que 3, mais c'est la manière la plus simple et concise que j'ai trouvé pour l'instant :

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
 
int * a, *b;
int ** c;
 
a = malloc(taille);
b = malloc(taille);
c = malloc(taille2);
 
if(a == NULL || b == NULL || c == NULL) {
	free(a);
	free(b);
	free(c);
	return -1;
}
 
//je met tout à null pour pouvoir faire un free sur tous au cas ou un échoue.
for(i = 0 ; i < taille2 ; i++) {
	c[i] = NULL;
}
 
for(i = 0 ; i < taille2 ; i++) {
	c[i] = malloc(taille);
	if( c[i] == NULL) {
		free(a);
		free(b);
		for(i = 0 ; i < taille2 ; i++) {
			free(c[i]);
		}
		free(c);
		return -1;
	}
}
 
//ouf tous les mallocs ont fonctionnés :roll:
 
//on peut maintenant ecrire le reste de la fonction sans oublier de faire un free pour tous les pointeurs a la fin

**diogene** · 21/02/2008, 17h41

Code :

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

1
2
3
4
5
6
7
8
9
10
a = malloc(taille);
b = malloc(taille);
c = malloc(taille2);
 
if(a == NULL || b == NULL || c == NULL) {
	free(a);
	free(b);
	free(c);
	return -1;
}

Ceci est correct. On peut faire free(NULL) en toute sécurité

Tu peux te dispenser de la mise à NULL préalable des c[i] :

Code :

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

1
2
3
4
5
6
7
 
...
	c[i] = malloc(taille);
	if( c[i] == NULL) {
...
		for(j = 0 ; j < i ; j++) free(c[j]);
....

**souviron34** · 21/02/2008, 17h50

Envoyé par diogene

On peut faire free(NULL) en toute sécurité

pas sur tous les systemes... HPUX et SunOs crashent... (enfin crashaient il y a 6 ans)

**souviron34** · 21/02/2008, 17h53

et pour eviter de faire :

Code :

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

1
2
3
4
 
for(i = 0 ; i < taille2 ; i++) {
	c[i] = NULL;
}

il suffirait de faire

Code :

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

c = calloc ( taille2, sizeof(int *) );

Et d'ailleurs tes pointeurs sont declares comme des entiers (pointeurs), mais tu alloues des bytes...

**contremaitre** · 21/02/2008, 17h55

Envoyé par souviron34

Et d'ailleurs tes pointeurs sont declares comme des entiers (pointeurs), mais tu alloues des bytes...

Oui mais c'etait pour simplifier le code je ne fait pas ca dans un vrai code.
J'aurai fait a = malloc (taille*sizeof(*a))
Cet exemple était pour illustrer la lourdeur d'allouer plusieurs zones memoires sans risquer de fuites en cas d'echec.

**souviron34** · 21/02/2008, 17h57

faire du code resistant a tout signifie en general au moins 50% de code pour gerer les erreurs !!!!!

**orfix** · 21/02/2008, 22h15

Envoyé par souviron34

et pour eviter de faire :

Code :

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

1
2
3
4
 
for(i = 0 ; i < taille2 ; i++) {
	c[i] = NULL;
}

il suffirait de faire

Code :

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

c = calloc ( taille2, sizeof(int *) );

Et d'ailleurs tes pointeurs sont declares comme des entiers (pointeurs), mais tu alloues des bytes...

calloc ne garantis pas la mise à NULL ...enfin c'est ce que j'ai compris en lisant les nombreux postes traitant du "all bits zero" et de cette fameuse "trap representation" ....peut être que je me trompe c'est plus une confirmation que j'attends

**corrector** · 07/03/2008, 22h40

Envoyé par ssmario2

calloc ne garantis pas la mise à NULL ...enfin c'est ce que j'ai compris en lisant les nombreux postes traitant du "all bits zero" et de cette fameuse "trap representation" ....peut être que je me trompe c'est plus une confirmation que j'attends

Et tu as parfaitement raison : la représentation d'un pointeur nul n'est pas forcément tous les bits à 0.

**Thierry Chappuis** · 08/03/2008, 08h48

Envoyé par ssmario2

calloc ne garantis pas la mise à NULL ...enfin c'est ce que j'ai compris en lisant les nombreux postes traitant du "all bits zero" et de cette fameuse "trap representation" ....peut être que je me trompe c'est plus une confirmation que j'attends

Tu as raison, rien ne garantit que NULL est représenté avec tous les bits à zéro. Dans ce contexte, il n'est pas possible de se fier à calloc() pour initialiser un tableau de pointeur ou un tableau de flottants à une valeur nulle (NULL ou 0.0 respectivement). C'est en revanche OK pour les entiers.

EDIT: Oups, désolé corrector, ça m'apprendra à répondre sans avoir lu le fil jusqu'à la fin

Thierry

**contremaitre** · 21/02/2008, 17h53

J'ai toujours lu dans man free

Si ptr est NULL, aucune tentative de libération n'a lieu.

donc j'utilise cette propriété.
Si ça ne marche pas sur tous les sytemes, je ne le savais pas, mais ça change pas trop ma question d'origine qui est :

Je voudrais savoir si vous avez des methodes pour gérer les malloc et leurs tests si ils echouent.

**Médinoc** · 21/02/2008, 17h57

Un système qui crashe sur un free(NULL) ne respecte pas la norme du C ANSI.

Donc, sur tout système au moins respectueux du standard C90 (voire C89), free(NULL) est garanti ne pas crasher.

**diogene** · 21/02/2008, 18h02

Envoyé par souviron34

pas sur tous les systemes... HPUX et SunOs crashent... (enfin crashaient il y a 6 ans)

Je me réfère aux bons auteurs :

n1124 me dit

7.20.3.2 The free function
Synopsis
1 #include <stdlib.h>
void free(void *ptr);
Description
2 The free function causes the space pointed to by ptr to be deallocated, that is, made
available for further allocation. If ptr is a null pointer, no action occurs....

alors, moi je la crois!

**souviron34** · 21/02/2008, 19h32

Envoyé par Médinoc

Un système qui crashe sur un free(NULL) ne respecte pas la norme du C ANSI.

Donc, sur tout système au moins respectueux du standard C90 (voire C89), free(NULL) est garanti ne pas crasher.

Envoyé par diogene

Je me réfère aux bons auteurs :

n1124 me dit

alors, moi je la crois!

essaye sur un HPUX 10.2 ...

ou un serveur HP K(230 ??), ou une station SGI Irix Indigo de 1997..

**souviron34** · 21/02/2008, 17h43

Arrete de poster n'importe quoi, ou bien pose des questions !!!!

Ton code cointient au moins 4 raisons de crasher sans avertissement,....

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
int * a, *b;
int ** c;
 
a = malloc(taille);
b = malloc(taille);
c = malloc(taille2);
 
if(a == NULL || b == NULL || c == NULL) {
/**** OU SONT LES TESTS POUR SAVOIR LEQUEL EST NULL ??? ****/
	free(a);
	free(b);
	free(c);
	return -1;
}
 
//je met tout à null pour pouvoir faire un free sur tous au cas ou un échoue.
for(i = 0 ; i < taille2 ; i++) {
	c[i] = NULL;
}
 
for(i = 0 ; i < taille2 ; i++) {
	c[i] = malloc(taille);
	if( c[i] == NULL) {
		free(a);
		free(b);
/**** DE i A taille2 IL N'Y A RIEN D'ALLOUE !!!!!! ****/
		for(i = 0 ; i < taille2 ; i++) {
			free(c[i]);
		}
		free(c);
		return -1;
	}
}
 
//ouf tous les mallocs ont fonctionnés :roll:
 
//on peut maintenant ecrire le reste de la fonction sans oublier de faire un free pour tous les pointeurs a la fin

Une bonne maniere de faire serait :

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
int j ;
int * a=NULL, *b=NULL;
int ** c=NULL;
 
a = malloc(taille);
b = malloc(taille);
c = malloc(taille2);
 
if(a == NULL || b == NULL || c == NULL) {
         if ( a != NULL )
	free(a);
         if ( b != NULL )
	free(b);
         if ( c != NULL )
	free(c);
	return -1;
}
 
//je met tout à null pour pouvoir faire un free sur tous au cas ou un échoue.
for(i = 0 ; i < taille2 ; i++) {
	c[i] = NULL;
}
 
for(i = 0 ; i < taille2 ; i++) {
	c[i] = malloc(taille);
	if( c[i] == NULL) {
		free(a);
		free(b);
                         if ( i != 0 )
  		  for(j = (i-1) ; j >= 0 ; j--) {			free(c[j]);
		}
		free(c);
		return -1;
	}
}
 
//ouf tous les mallocs ont fonctionnés :roll:
 
//on peut maintenant ecrire le reste de la fonction sans oublier de faire un free pour tous les pointeurs a la fin

**contremaitre** · 21/02/2008, 17h46

Envoyé par souviron34

Arrete de poster n'importe quoi, ou bien pose des questions

Ton code contient au moins 4 raisons de crasher sans avertissement,....

Pas la peine de s'énerver... mon code ne crashe pas car il n'y a pas besoin de tester lequel est à NULL vu qu'on peut faire free(NULL) (cf man free)

Meme explication pour ta deuxième phrase en rouge -> j'avais initialisé a null

Quand à "ou bien pose des questions", j'en ai posé une : c'est comment rendre ca moins lourd à gerer... je demande vos méthode pour ce genre de choses...

Tu a sans doute mal lu mon post

**Emmanuel Delahaye** · 22/02/2008, 03h15

Envoyé par souviron34

Une bonne maniere de faire serait :

Code :

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

1
2
3
4
5
6
7
8
int j ;
int * a=NULL, *b=NULL;
int ** c=NULL;
 
a = malloc(taille);
b = malloc(taille);
c = malloc(taille2);

Euh, il n'y a pas de différence entre

Code :

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

1
2
3
4
 
T *p;
 
   p = malloc(...);

,

Code :

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

1
2
3
4
 
T *p = NULL;
 
   p = malloc(...);

et

Code :

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

1
2
 
T *p = malloc(...);

Personnellement, la 3ème forme a ma préférence...

Envoyé par souviron34

pas sur tous les systemes... HPUX et SunOs crashent... (enfin crashaient il y a 6 ans)

Non conformité au langage C ? C'est grave...

Envoyé par souviron34

faire du code resistant a tout signifie en general au moins 50% de code pour gerer les erreurs !!!!!

+1

Envoyé par pasdeface

Je voudrais savoir si vous avez des methodes pour gérer les malloc et leurs tests si ils echouent.

Dans un premier temps, je fais comme ça :

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
#include <stdlib.h>
#include <assert.h>
 
int main (void)
{
   int taille = 3;
   int taille2 = 4;
 
   int *a = malloc (taille * sizeof *a);
   if (a != NULL)
   {
      int *b = malloc (taille * sizeof *b);
      if (b != NULL)
      {
         int **c = malloc (taille2 * sizeof *c);
         if (c != NULL)
         {
 
/* je met tout à null pour pouvoir faire
un free sur tous au cas ou un échoue. */
            {
               int i;
               for (i = 0; i < taille2; i++)
               {
                  c[i] = NULL;
               }
            }
 
            {
               int err = 0;
               {
                  int i;
                  for (i = 0; !err && i < taille2; i++)
                  {
                     c[i] = malloc (taille * sizeof *c[i]);
                     if (c[i] == NULL)
                     {
                        err = 1;
                     }
                  }
               }
               if (err)
               {
                  /* tout liberer */
                  int i;
                  for (i = 0; i < taille2; i++)
                  {
                     free (c[i]);
                  }
                  free (c), c = NULL;
                  free (b), b = NULL;
                  free (a), a = NULL;
               }
            }
 
            /* usage */
 
            /* liberation */
            {
               int i;
               for (i = 0; i < taille2; i++)
               {
                  free (c[i]);
               }
               free (c), c = NULL;
            }
         }
         free (b), b = NULL;
 
         assert (c == NULL);
      }
      free (a), a = NULL;
 
      assert (b == NULL);
   }
   assert (a == NULL);
 
   return 0;
}

Mais dans la vraie vie, ce serait évidemment différent :

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
 
/* main.c */
#include <stdlib.h>
 
#include "x.h"
 
int main (void)
{
   /* creation */
   struct x *p = x_create (3, 4);
 
   if (p != NULL)
   {
      /* usage */
 
      /* liberation */
      x_delete (p);
   }
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* x.h */
#ifndef H_ED_X_20080222035637
#define H_ED_X_20080222035637
 
struct x;
 
struct x *x_create(int taille, int taille2);
void x_delete(struct x *self);
 
#endif /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
/* x.c */
#include "x.h"
 
#include <stdlib.h>
 
struct x
{
   int *a;
   int *b;
   int **c;
   int taille2;
};
 
struct x *x_create (int taille, int taille2)
{
   struct x *self = malloc (sizeof *self);
   if (self != NULL)
   {
      /* tout a 0 */
      {
         static const struct x z = { 0 };
         *self = z;
      }
 
      self->a = malloc (taille * sizeof *self->a);
      if (self->a != NULL)
      {
         self->b = malloc (taille * sizeof *self->b);
         if (self->b != NULL)
         {
            self->c = malloc (taille2 * sizeof *self->c);
            if (self->c != NULL)
            {
 
/* je met tout à null pour pouvoir faire
un free sur tous au cas ou un échoue. */
               {
                  int i;
                  for (i = 0; i < taille2; i++)
                  {
                     self->c[i] = NULL;
                  }
               }
 
               {
                  int err = 0;
                  {
                     int i;
                     for (i = 0; !err && i < taille2; i++)
                     {
                        self->c[i] = malloc (taille * sizeof *self->c[i]);
                        if (self->c[i] == NULL)
                        {
                           err = 1;
                        }
                     }
                  }
                  if (err)
                  {
                     x_delete (self), self = NULL;
                  }
                  else
                  {
                     self->taille2 = taille2;
                  }
               }
            }
            else
            {
               x_delete (self), self = NULL;
            }
         }
         else
         {
            x_delete (self), self = NULL;
         }
      }
      else
      {
         x_delete (self), self = NULL;
      }
   }
   return self;
}
 
void x_delete (struct x *self)
{
   if (self != NULL)
   {
      if (self->c != NULL)
      {
         /* tout liberer */
         int i;
         for (i = 0; i < self->taille2; i++)
         {
            free (self->c[i]);
         }
         free (self->c);
      }
      free (self->b);
      free (self->a);
      free (self);
   }
}

**contremaitre** · 27/03/2008, 13h47

Envoyé par Emmanuel Delahaye

Code :

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

1
2
3
4
5
6
 
      /* tout a 0 */
      {
         static const struct x z = { 0 };
         *self = z;
      }

Est ce que ça initialise les pointeurs à NULL de faire ça?
(les pointeurs à l'intérieur de la structure je parle)

**Médinoc** · 27/03/2008, 13h48

Oui.

**Thierry Chappuis** · 27/03/2008, 13h51

Envoyé par pasdeface

Est ce que ça initialise les pointeurs à NULL de faire ça?

Ca initialise tous les champs de la structure à la valeur nulle adéquate i.e. NULL pour un pointeur, 0 pour un entier, 0.0 pour un flottant de type double, etc.

Thierry

**contremaitre** · 22/02/2008, 08h33

merci

gestion mémoire sur plusieurs malloc

C

Vue hybride

Discussions similaires

Partager

Partager