gestion mémoire sur plusieurs malloc

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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

Code:

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:

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

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

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

Code:

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:

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

21/02/2008, 17h46
contremaitre

Citation:

Envoyé par souviron34

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

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 :(
21/02/2008, 17h50
souviron34

Citation:

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)
21/02/2008, 17h53
souviron34
et pour eviter de faire :
Code:

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

Code:

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

Et d'ailleurs tes pointeurs sont declares comme des entiers (pointeurs), mais tu alloues des bytes...
21/02/2008, 17h53
contremaitre

J'ai toujours lu dans man free

Citation:

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.
21/02/2008, 17h55
contremaitre

Citation:

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.
21/02/2008, 17h57
souviron34

faire du code resistant a tout signifie en general au moins 50% de code pour gerer les erreurs !!!!!
21/02/2008, 17h57
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.
21/02/2008, 18h02
diogene

Citation:

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

Citation:

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!:P
21/02/2008, 18h05
contremaitre

Citation:

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.
21/02/2008, 18h11
souviron34

Citation:

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...
21/02/2008, 19h32
souviron34

Citation:

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.

Citation:

Envoyé par diogene

Je me réfère aux bons auteurs :

n1124 me dit

alors, moi je la crois!:P

essaye sur un HPUX 10.2 ... ;) ou un serveur HP K(230 ??), ou une station SGI Irix Indigo de 1997.. ;)
21/02/2008, 22h15
orfix
Citation:
Envoyé par souviron34

et pour eviter de faire :

Code:

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

il suffirait de faire

Code:

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 :aie:

Citation:

Envoyé par souviron34

Une bonne maniere de faire serait :

Code:

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:

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

Code:

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

Code:

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

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

Citation:

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

Citation:

Envoyé par souviron34

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

Citation:

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:

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:

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:

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:

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);
   }
}

22/02/2008, 08h33
contremaitre

merci
06/03/2008, 14h44
contremaitre

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
06/03/2008, 15h22
Médinoc

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.
06/03/2008, 15h24
contremaitre

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

Voir 40 message(s) de cette discussion en une page