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, 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

**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, 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.

**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 !!!!!

**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!

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

Envoyé par souviron34

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

oui, mais bon je me dit qu'il doit bien y avoir une maniere plus simple de gerer ce genre de cas.
Car si on a n zones mémoire à allouer (dont certaines avec des allocations d'allocations), alors pour gerer la liberation des zones non alloués si ca foire en plein milieu, c'est pas 50% mais 99% de code pour gerer les erreurs si n est assez grand.

**souviron34** · 21/02/2008, 18h11

Envoyé par pasdeface

oui, mais bon je me dit qu'il doit bien y avoir une maniere plus simple de gerer ce genre de cas.
Car si on a n zones mémoire à allouer (dont certaines avec des allocations d'allocations), alors pour gerer la liberation des zones non alloués si ca foire en plein milieu, c'est pas 50% mais 99% de code pour gerer les erreurs si n est assez grand.

si tu en as autant et que ce n'est pas en tableau, alors c'est sans doute une erreur de conception..

Sinon eh bien oui, cela peut etre 99% du code d'une fonction...

**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..

**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

**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** · 22/02/2008, 08h33

merci

**contremaitre** · 06/03/2008, 14h44

Me revoilà.

Emmanuel Delahaye, ton exemple me plait beaucoup mais j'ai du mal a le comprendre.

Pourquoi les membres de struct x sont défnis dans x.c ?
Comment on peut accéder aux membres de p (de type struct x) dans le main ?

merci

**Médinoc** · 06/03/2008, 15h22

Justement, avec un Type Abstrait de Données (TAD), on n'y accède pas. On peut seulement appeler des fonctions qui y accèdent, et qui sont elles aussi définies dans x.c.

**contremaitre** · 06/03/2008, 15h24

ha, c'est un équivalent des classes en c++?

gestion mémoire sur plusieurs malloc

C

Discussions similaires

Partager

Partager