calloc pointeur & co

Version imprimable

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
 
 
   typedef struct Snoeud {
      char *nom;
      struct Slistnoeuds *listadj;
      struct Snoeud *suivant;
      int couleur;
   } Tnoeud;
 
   typedef struct Smaillon {
      Tnoeud *noeud;
      struct Smaillon *suivant;
   } Tmaillon, Tadjacent, Telement;
 
 
   typedef struct Slistnoeuds {
      struct Smaillon *maillon;
      int taille;
   } Tlistnoeuds, Tlistadj, Tpartition;
 
   Tnoeud nouveau_noeud() {
   // malloc(sizeof(Tnoeud)) etc
   };
 
   Tmaillon nouveau_maillon() {
   // malloc(sizeof(Tmaillon)) etc
   };
 
   void ajouter_maillon(Tlistnoeuds *l, Tnoeud *n) {
     if (l->maillon == NULL) l->maillon=nouveau_maillon(n);
     else {
         Tmaillon *tete=nouveau_maillon(n);
         tete->suivant=l->maillon;
         l->maillon=tete;
      }
      l->taille++;
   };
 
 
    void vider_listnoeuds(Tlistnoeuds * l) {
      Tmaillon *iterator=l->maillon;
      Tmaillon *suivant;
      while (iterator != NULL) {
         suivant=iterator->suivant;
         free(iterator);
         iterator=suivant;
      }
      l->maillon= NULL;
      l->taille= 0;
   }
 
 
   void exemple(void) {
      int taille=5;
      Tnoeud *n=nouveau_noeud("arf");
      Tpartition * blanc;
      Tpartition * noir;
 
      blanc= (Tpartition *) calloc(taille,sizeof(Tpartition));
      noir= (Tpartition *) calloc(taille,sizeof(Tpartition));
 
      ajouter_maillon(&blanc[0],n); // <- fonctionne
      vider_listnoeuds(&blanc[0]);
      ajouter_maillon(&blanc[0],n); // <- plantage
   };

Comme vous vous en doutez, j'aimerai bien comprendre...
vider_listnoeuds prend en parametre l'adresse de la listnoeuds d'indice i
libere les maillons et affecte null à l->maillon et 0 à l->taille.
la zone memoire l n'est pas libéré... Merci de m'éclairer.
Ca me soule :)

Re: calloc pointeur & co

Citation:

Envoyé par evlad

Ca me soule :)

Moi, ce qui me saoule, c'est que le code ne soit pas compilable...

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
 
Compiling: main.c
main.c:19: warning: function declaration isn't a prototype
main.c:23: warning: function declaration isn't a prototype
main.c:27: warning: no previous prototype for 'ajouter_maillon'
main.c: In function `ajouter_maillon':
main.c:28: error: `NULL' undeclared (first use in this function)
main.c:28: error: (Each undeclared identifier is reported only once
main.c:28: error: for each function it appears in.)
main.c:28: error: incompatible types in assignment
main.c:30: error: incompatible types in initialization
main.c: At top level:
main.c:38: warning: no previous prototype for 'vider_listnoeuds'
main.c: In function `vider_listnoeuds':
main.c:41: error: `NULL' undeclared (first use in this function)
main.c:43: error: implicit declaration of function `free'
main.c:43: warning: nested extern declaration of `free'
main.c: At top level:
main.c:51: warning: no previous prototype for 'exemple'
main.c: In function `exemple':
main.c:53: error: incompatible types in initialization
main.c:57: error: implicit declaration of function `calloc'
main.c:57: warning: nested extern declaration of `calloc'
<internal>:0: warning: redundant redeclaration of 'calloc'
main.c:57: warning: passing arg 1 of `calloc' as unsigned due to prototype
main.c:58: warning: passing arg 1 of `calloc' as unsigned due to prototype
main.c:63:7: warning: no newline at end of file
main.c: In function `nouveau_noeud':
main.c:19: warning: function returns an aggregate
main.c: In function `nouveau_maillon':
main.c:23: warning: function returns an aggregate
Process terminated with status 1 (0 minutes, 0 seconds)

Ceci ne plante pas.

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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
#include <stdlib.h>
 
typedef struct Snoeud
{
   char const *nom;
 
   struct Slistnoeuds *listadj;
 
   struct Snoeud *suivant;
   int couleur;
}
Tnoeud;
 
typedef struct Smaillon
{
   Tnoeud *noeud;
 
   struct Smaillon *suivant;
}
Tmaillon;
 
 
typedef struct Slistnoeuds
{
 
   struct Smaillon *maillon;
   int taille;
}
Tlistnoeuds, Tlistadj ;
 
static Tnoeud *nouveau_noeud(char const *s)
{
   Tnoeud * n = malloc(sizeof * n);
 
   if (n != NULL)
   {
      static const Tnoeud z =
         {
            0
         };
      *n = z;
 
      n->nom = s;
   }
 
   return n;
};
 
static Tmaillon *nouveau_maillon(Tnoeud *n)
{
   Tmaillon * m = malloc(sizeof * m);
 
   if (m != NULL)
   {
      static const Tmaillon z =
         {
            0
         };
      *m = z;
 
      m->noeud = n;
   }
 
   return m;
};
 
static void ajouter_maillon(Tlistnoeuds *l, Tnoeud *n)
{
   if (l->maillon == NULL)
   {
      l->maillon = nouveau_maillon(n);
   }
   else
   {
      Tmaillon *tete = nouveau_maillon(n);
      tete->suivant = l->maillon;
      l->maillon = tete;
   }
 
   l->taille++;
};
 
static void vider_listnoeuds(Tlistnoeuds * l)
{
   Tmaillon *iterator = l->maillon;
   Tmaillon *suivant;
 
   while (iterator != NULL)
   {
      suivant = iterator->suivant;
      free(iterator);
      iterator = suivant;
   }
 
   l->maillon = NULL;
   l->taille = 0;
}
 
static void exemple(void)
{
   int taille = 5;
   Tnoeud *n = nouveau_noeud("arf");
   Tlistnoeuds * blanc;
   Tlistnoeuds * noir;
 
   blanc = (Tlistnoeuds *) calloc(taille, sizeof * blanc);
   noir = (Tlistnoeuds *) calloc(taille, sizeof * noir);
 
   ajouter_maillon(&blanc[0], n); // <- fonctionne
   vider_listnoeuds(&blanc[0]);
   ajouter_maillon(&blanc[0], n); // <- plantage
}
 
int main (void)
{
   exemple() ;
 
   return 0;
}

Evidemment, il y a des fuites mémoire...

Code:

1
2
3
4
5
6
 
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D24E0 (16 bytes) malloc'ed at line 33 of 'main.c' not freed
SYSALLOC Bloc 003D24F8 (40 bytes) calloc'ed at line 106 of 'main.c' not freed
SYSALLOC Bloc 003D2528 (40 bytes) calloc'ed at line 107 of 'main.c' not freed
SYSALLOC Bloc 003D2470 (8 bytes) malloc'ed at line 51 of 'main.c' not freed

11/12/2005, 02h14
evlad

Excuse moi pas, je n'avais pas tout mis, c'était un condensé pour la mise en situation... et l'exemple n'etait pas bon en fait (trop simple)

Dans mon programme,

Je remplissais les partitions blanche et noire dans une procedure (en passant l'adresse des deux tableaux de listes blanc et noir.

Je vidais la liste de chaque case du tableau au fur et a mesure dans une autre procedure.

Lorsque je revenais dans la procedure ou avait été initialisé a l'aide de calloc les deux tableaux et que je voulais ajouté un maillon à la liste d'un case du tableau : plantage.

L'erreur était vraiment inexplicable : pas d'erreurs de pointeurs ou quoi que ce soit.

Après m'etre retourné le cerveau dans tous les sens j'ai decidé de tenter avec un autre compilateur (gcc) (j'utilisais le compilateur borland 5).
J'install donc devc++ et la miracle ca marche parfaitement...

Le delire...
Je n'avais pas codé en C depuis longtemps, ca ne me manquait pas...
Malheureusement le prof veux absolument que l'on code notre projet d'algorithmie en C. Bon ca m'aura permet de jouir gaiement des pointeurs... :)

En tout cas merci