Conflit d'adresse de champs de liste chaînée

**Anthony_CTI** · 21/07/2011, 16h39

Bonjour, je développe un programme qui parcours une liste chaînée comportant plusieurs champs. Certains de ces champs sont des pointeurs vers d'autres listes chaînées.

Mon problème: Il semble qu'un champ (contenant l'adresse d'une liste chaînée) ai la même adresse d'un maillon à l'autre.

Illustration:

Voici la définition de la liste chaînée concernée

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
/* list chainer d'elements pour la lecture des donnees */
typedef struct lc_t_elem_ {
   INT num;                    /* numero d'element */
   INT typel;                  /* type de l'element */
   INT taille;                 /* taille de la connectivite */
   LCTINT *connect;            /* connectivite de l'element */
   LCTREEL *vectori;           /* vecteur d'orientation pour les poutres */
   INT prop;                   /* numero de propriete associer */
   INT stratif;                /* numero de la stratification associer */
   INT repere;                 /* numero de repere de definition de la stratification */
   INT repere_contraintes;     /* repere de contrainte */
   char *n1,*n2;               /* chaine de charactere */
   REEL coef;                  /* coeficiant multiplicatif pour les supers elements */
   struct lc_t_elem_ *suiv;    /* pointeur sur l'element suivant de la liste */
} LCTELEM;

Voici le code qui sert à parcourir la liste chaînée(beaucoup de lignes sont des affichages et ne servent qu'au debbug)

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
106
107
108
/* remplissage de la table
     des elements :  elements poutre en deuxieme
     ------------------------------------------- */
  m=3;
  if (nb_elpou)
  {
     for (p_lctelem=pb_lctelem;p_lctelem->num>0;p_lctelem=p_lctelem->suiv)
     {
 
         if (p_lctelem->typel==TYEL_P_ )
         {
			printf("\n\nadresse du maillon traité = (%d) \n",p_lctelem);
           pi[k]=p_lctelem->num;
           p1[k]=TYEL_P_;
           p2[k++]=p_lctelem->prop;
           dealloc_lctentier(&pk[l],p_lctelem->connect);
 
			//______________________________________________________________________________
			int inc;
			printf("m = %d\n",m);
			printf("pr[m] (%d)\n",&pr[m]);
			printf("p_lctelem(%d)->vectori (%d)\n",p_lctelem,p_lctelem->vectori);
 
			LCTREEL* tmpp2;
			tmpp2=p_lctelem->vectori;
			printf("vectori :");
			while(tmpp2!=NULL){
			printf("%.1f; ",tmpp2->val);
			tmpp2=tmpp2->suiv;
			}
 
			printf("\n");
			//______________________________________________________________________________
 
 
 
           dealloc_lctreel(&pr[m],p_lctelem->vectori);
           distinct(&pk[l], &c__1, &p_lctelem->taille, &n, &q, &ok); 
           if (ok!=TRUE_)
           {
              dammsg(ERR_CONECTELEM_,ERR_CHOERELEMP_,p_lctelem->num,pk[l+n-1],n,q,routine);
              return(-1);
           }
           l+=p_lctelem->taille;
           m+=9;
           pj[k]=l+1;
         }
     }
  }
 
 
 
 
  /* remplissage de la table
     des elements :  elements ressort en troisième
     ------------------------------------------- */
 
  if (nb_elress)
  {
     for (p_lctelem=pb_lctelem;p_lctelem->num>0;p_lctelem=p_lctelem->suiv)
     {
 
         if (p_lctelem->typel==TYEL_RESS_ )
         {
			printf("\n\nadresse du maillon traité = (%d) \n",p_lctelem);
            pi[k]=p_lctelem->num;
            p1[k]=TYEL_RESS_;
            p2[k]=p_lctelem->prop;
			printf("p2[k] = %d \n",p2[k]);
			printf("p_lctelem->prop = %d \n",p_lctelem->prop);
			k++;
			printf("p_lctelem->connect (%d)\n",p_lctelem->connect);
            dealloc_lctentier(&pk[l],p_lctelem->connect);
			//______________________________________________________________________________
			int inc;
			printf("m = %d\n",m);
			printf("pr[m] (%d)\n",&pr[m]);
 
			for (inc=0;inc<9*(nb_elpou+nb_elress);inc++){
			printf("pr[%d] = %f\t",inc,pr[inc]);
			if ((inc+1)%9==0)printf("\n");
			}
 
			printf("p_lctelem(%d)->vectori (%d)\n",p_lctelem,p_lctelem->vectori);
 
			LCTREEL* tmpp2;
			tmpp2=p_lctelem->vectori;
			printf("vectori :");
			while(tmpp2!=NULL){
			printf("%.1f; ",tmpp2->val);
			tmpp2=tmpp2->suiv;
			}
 
			printf("\n");
			//______________________________________________________________________________
           // dealloc_lctreel(&pr[m],p_lctelem->vectori);
           // distinct(&pk[l], &c__1, &p_lctelem->taille, &n, &q, &ok); 
           // if (ok!=TRUE_)
           // {
              // dammsg(ERR_CONECTELEM_,ERR_CHOERELEMP_,p_lctelem->num,pk[l+n-1],n,q,routine);
              // return(-1);
           // }
            l+=p_lctelem->taille;
            m+=9;
            pj[k]=l+1;
         }
     }
  }

Voici les affichages récupérés après avoir fait tourné le programme:

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
 
adresse du maillon traité = (529106080) 
m = 3
pr[m] (529086696)
p_lctelem(529106080)->vectori (529106240)
vectori :1.0; 0.0; 0.0; 
 
 
adresse du maillon traité = (529106336) 
m = 12
pr[m] (529086768)
p_lctelem(529106336)->vectori (529106496)
vectori :1.0; 0.0; 0.0; 
 
 
adresse du maillon traité = (529106592) 
p2[k] = 1 
p_lctelem->prop = 1 
p_lctelem->connect (529106688)
m = 21
pr[m] (529086840)
pr[0] = 0.000000	pr[1] = 0.000000	pr[2] = 0.000000	pr[3] = 1.000000	pr[4] = 0.000000	pr[5] = 0.000000	pr[6] = 0.000000	pr[7] = 0.000000	pr[8] = 0.000000	
pr[9] = 0.000000	pr[10] = 0.000000	pr[11] = 0.000000	pr[12] = 1.000000	pr[13] = 0.000000	pr[14] = 0.000000	pr[15] = 0.000000	pr[16] = 0.000000	pr[17] = 0.000000	
pr[18] = 0.000000	pr[19] = 0.000000	pr[20] = 0.000000	pr[21] = 0.000000	pr[22] = 0.000000	pr[23] = 0.000000	pr[24] = 0.000000	pr[25] = 0.000000	pr[26] = 0.000000	
pr[27] = 0.000000	pr[28] = 0.000000	pr[29] = 0.000000	pr[30] = 0.000000	pr[31] = 0.000000	pr[32] = 0.000000	pr[33] = 0.000000	pr[34] = 0.000000	pr[35] = 0.000000	
p_lctelem(529106592)->vectori (529106496)
vectori :0.0; 0.0; 0.0; 
 
 
adresse du maillon traité = (529106752) 
p2[k] = 1 
p_lctelem->prop = 1 
p_lctelem->connect (529106848)
m = 30
pr[m] (529086912)
pr[0] = 0.000000	pr[1] = 0.000000	pr[2] = 0.000000	pr[3] = 1.000000	pr[4] = 0.000000	pr[5] = 0.000000	pr[6] = 0.000000	pr[7] = 0.000000	pr[8] = 0.000000	
pr[9] = 0.000000	pr[10] = 0.000000	pr[11] = 0.000000	pr[12] = 1.000000	pr[13] = 0.000000	pr[14] = 0.000000	pr[15] = 0.000000	pr[16] = 0.000000	pr[17] = 0.000000	
pr[18] = 0.000000	pr[19] = 0.000000	pr[20] = 0.000000	pr[21] = 0.000000	pr[22] = 0.000000	pr[23] = 0.000000	pr[24] = 0.000000	pr[25] = 0.000000	pr[26] = 0.000000	
pr[27] = 0.000000	pr[28] = 0.000000	pr[29] = 0.000000	pr[30] = 0.000000	pr[31] = 0.000000	pr[32] = 0.000000	pr[33] = 0.000000	pr[34] = 0.000000	pr[35] = 0.000000	
p_lctelem(529106752)->vectori (529106496)
vectori :0.0; 0.0; 0.0;

Remarque: L'adresse du maillon traité évolue correctement tandis que l'adresse du champs "vectori" des maillon ne change qu'une fois et ensuite reste la même.

Merci d'avance,

Anthony

**souviron34** · 22/07/2011, 13h56

trop compliqué.. Isole le pbe stp..

Mais surtout on n'a pas la routine de création d'un élément... et si je regarde dans le code que tu donnes, je ne vois rien qui assigne ton fameux vectori...

**Anthony_CTI** · 25/07/2011, 10h01

Ok,

Voici la routine qui initialise les listes chaînées. La ligne concernée est la huitième après le "if" (p_lctelem).

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
 
/* 
   INITIALISATION DES LISTE CHAINER PAR ALLOCATION 
   D'OBJETS POUR CHAQUE TYPE DE CHAINE :
      parametres
       en entre
         - 
 
       en sortie
         - 
      appelle : -
      est appeller par : (c)
 
      retourne 0 ou -1 en cas de probleme 
  
*/
INT init_lc(void)
{
 
  if ( !(pb_lctcart   =p_lctcart   =alloc_maillon_lctcart()    )  ||
       !(pb_lctccla   =p_lctccla   =alloc_maillon_lctccla()    )  ||
       !(pb_lctccl    =p_lctccl    =alloc_maillon_lctccl()     )  ||
       !(pb_lctcmd    =p_lctcmd    =alloc_maillon_lctcmd()     )  ||
       !(pb_lctdepblq =p_lctdepblq =alloc_maillon_lctcl()      )  ||
       !(pb_lctdepimp =p_lctdepimp =alloc_maillon_lctcl()      )  ||
       !(pb_lcteffimp =p_lcteffimp =alloc_maillon_lctcl()      )  ||
       !(pb_lctelem   =p_lctelem   =alloc_maillon_lctelem()    )  ||
       !(pb_lctmat    =p_lctmat    =alloc_maillon_lctmat()     )  ||
       !(pb_lctmattv  =p_lctmattv  =alloc_maillon_lctmattv()   )  ||
       !(pb_lctnoeud  =p_lctnoeud  =alloc_maillon_lctnoeud()   )  ||
       !(pb_lctpil    =p_lctpil    =alloc_maillon_lctpil()     )  ||
       !(pb_lctpresimp=p_lctpresimp=alloc_maillon_lctcl()      )  ||
       !(pb_lctpropnum=p_lctpropnum=alloc_maillon_lctpropnum() )  ||
       !(pb_lctproppou=p_lctproppou=alloc_maillon_lctproppou() )  ||
       !(pb_lctpropress=p_lctpropress=alloc_maillon_lctpropress() )  ||
       !(pb_lctrelimp =p_lctrelimp =alloc_maillon_lctcl()      )  ||
       !(pb_lctrepere =p_lctrepere =alloc_maillon_lctrepere()  )  ||
       !(pb_lctstratif=p_lctstratif=alloc_maillon_lctstratif() )  ||
       !(pb_lctt      =p_lctt      =alloc_maillon_lctth()      )  ||
       !(pb_lcth      =p_lcth      =alloc_maillon_lctth()      )
     )
  {
      dammsg(ERR_PILE_,"init_lc");
      return(-1);
  }
 
  return(0);
 
}

Voici la fonction appelée dans init_lc:

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
 
/* 
   ALLOCATION D'OBJETS DE TYPE LCTELEM
      parametres
       en entre
         - 
 
       en sortie
         - 
      appelle : -
      est appeller par : yyparse(c),init_lc(c)
 
      retourne un pointeur sur la zone allouer ou null en cas d'erreur
  
*/
LCTELEM *alloc_maillon_lctelem(void)
{
  LCTELEM *p;
 
  if ((p=(LCTELEM *)calloc(1,sizeof(LCTELEM)))==(LCTELEM *)NULL)
  {
      dammsg(ERR_ALLOCMEM_,"maillon reel","alloc_maillon_lctelem");
  }
 
  return(p);
 
}

Pour rappel, la structure LCTELEM est définie ici:

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
/* list chainer d'elements pour la lecture des donnees */
typedef struct lc_t_elem_ {
   INT num;                    /* numero d'element */
   INT typel;                  /* type de l'element */
   INT taille;                 /* taille de la connectivite */
   LCTINT *connect;            /* connectivite de l'element */
   LCTREEL *vectori;           /* vecteur d'orientation pour les poutres */
   INT prop;                   /* numero de propriete associer */
   INT stratif;                /* numero de la stratification associer */
   INT repere;                 /* numero de repere de definition de la stratification */
   INT repere_contraintes;     /* repere de contrainte */
   char *n1,*n2;               /* chaine de charactere */
   REEL coef;                  /* coeficiant multiplicatif pour les supers elements */
   struct lc_t_elem_ *suiv;    /* pointeur sur l'element suivant de la liste */
} LCTELEM;

et manipulée dans cette partie du code (simplifié par rapport au premier message):

Il y a deux paragraphes distincts construits selon la même logique: un pour les poutres et un pour les ressorts. Pour l'histoire, le programme fonctionne sans souci avec uniquement les poutres. L'insertion des ressorts est l'évolution sur laquelle je travaille. C'est donc la source probable du problème.

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
106
107
108
109
 
  /* remplissage de la table
     des elements :  elements poutre en deuxieme
     ------------------------------------------- */
  m=3;
  if (nb_elpou)
  {
     for (p_lctelem=pb_lctelem;p_lctelem->num>0;p_lctelem=p_lctelem->suiv)
     {
 
         if (p_lctelem->typel==TYEL_P_ )
         {
			printf("\n\nadresse du maillon traité = (%d) \n",p_lctelem);
           pi[k]=p_lctelem->num;
           p1[k]=TYEL_P_;
           p2[k++]=p_lctelem->prop;
           dealloc_lctentier(&pk[l],p_lctelem->connect);
 
			//______________________________________________________________________________
			int inc;
			printf("m = %d\n",m);
			printf("pr[m] (%d)\n",&pr[m]);
			printf("p_lctelem(%d)->vectori (%d)\n",p_lctelem,p_lctelem->vectori);
 
			LCTREEL* tmpp2;
			tmpp2=p_lctelem->vectori;
			printf("vectori :");
			while(tmpp2!=NULL){
			printf("%.1f; ",tmpp2->val);
			tmpp2=tmpp2->suiv;
			}
 
			printf("\n");
			//______________________________________________________________________________
 
 
 
           dealloc_lctreel(&pr[m],p_lctelem->vectori);
           distinct(&pk[l], &c__1, &p_lctelem->taille, &n, &q, &ok); 
           if (ok!=TRUE_)
           {
              dammsg(ERR_CONECTELEM_,ERR_CHOERELEMP_,p_lctelem->num,pk[l+n-1],n,q,routine);
              return(-1);
           }
           l+=p_lctelem->taille;
           m+=9;
           pj[k]=l+1;
         }
     }
  }
 
 
 
 
  /* remplissage de la table
     des elements :  elements ressort en troisième
     ------------------------------------------- */
 
  if (nb_elress)
  {
     for (p_lctelem=pb_lctelem;p_lctelem->num>0;p_lctelem=p_lctelem->suiv)
     {
 
         if (p_lctelem->typel==TYEL_RESS_ )
         {
			printf("\n\nadresse du maillon traité = (%d) \n",p_lctelem);
            pi[k]=p_lctelem->num;
            p1[k]=TYEL_RESS_;
            p2[k]=p_lctelem->prop;
			printf("p2[k] = %d \n",p2[k]);
			printf("p_lctelem->prop = %d \n",p_lctelem->prop);
			k++;
			printf("p_lctelem->connect (%d)\n",p_lctelem->connect);
            dealloc_lctentier(&pk[l],p_lctelem->connect);
			//______________________________________________________________________________
			int inc;
			printf("m = %d\n",m);
			printf("pr[m] (%d)\n",&pr[m]);
 
			for (inc=0;inc<9*(nb_elpou+nb_elress);inc++){
			printf("pr[%d] = %f\t",inc,pr[inc]);
			if ((inc+1)%9==0)printf("\n");
			}
 
			printf("p_lctelem(%d)->vectori (%d)\n",p_lctelem,p_lctelem->vectori);
 
			LCTREEL* tmpp2;
			tmpp2=p_lctelem->vectori;
			printf("vectori :");
			while(tmpp2!=NULL){
			printf("%.1f; ",tmpp2->val);
			tmpp2=tmpp2->suiv;
			}
 
			printf("\n");
			//______________________________________________________________________________
           // dealloc_lctreel(&pr[m],p_lctelem->vectori);
           // distinct(&pk[l], &c__1, &p_lctelem->taille, &n, &q, &ok); 
           // if (ok!=TRUE_)
           // {
              // dammsg(ERR_CONECTELEM_,ERR_CHOERELEMP_,p_lctelem->num,pk[l+n-1],n,q,routine);
              // return(-1);
           // }
            l+=p_lctelem->taille;
            m+=9;
            pj[k]=l+1;
         }
     }
  }

Remarque, les valeurs que prennent les champs de ces structures sont gérées par des analyseurs lexicaux et grammaticaux (flex et bison)qui interprètent un fichier de données rempli par l'utilisateur et stockent ces données dans les listes chaînées. Je peux essayer d'isoler le code concerné mais j'avoue que je le fais rarement. Le problème semblant concerner les adresses je ne me suis pas encore lancé...

Définition du problème:
La ligne suivante, présente dans le paragraphe gérant les ressorts est responsable d'une erreur de segmentation.

Code :

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

1
2
 
dealloc_lctreel(&pr[m],p_lctelem->vectori);

Lorsque je fais tourner mon programme normalement avec cette ligne, le terminal m'annonce une segfault et l'affichage du fichier de sortie s’arrête brutalement à un niveau correspondant à cette portion du code source.

Lorsque je le fais tourner avec un debbugger (gdb), le code annonce une segfault bien plus loin dans l'exécution du programme. (je pourrai développer cette remarque si ça semble nécessaire)

**souviron34** · 25/07/2011, 15h48

ben déjà on ne voit pas d'assignation ou d'allocation de vectori dans ta routine init_lc

Ensuite c'est une très mauvaise pratique de faire :

Code :

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

     !(pb_lctccla   =p_lctccla   =alloc_maillon_lctccla()

car tu compares un pointeur à un booléen..

Il se trouve que dans la plupart des implantations False vaut 0 et NULL == 0, mais ce n'est pas vrai partout...

D'autre part, si une allocation se passe mal, tu as des fuites de mémoire, puisque tu fais return sans avoir désalloué ce qui a déjà été alloué pour cet élément...

Enfin je ne vois pas vraiment de structure POUTRE ni de structure RESSORT, ce qui me semblerait logique..

**Anthony_CTI** · 26/07/2011, 10h02

Merci pour ces précisions.

En effet, lorsque j'utilise le debugger gdb pour suivre les changements de valeurs du pointeur p_lctelem.vectori, je m'aperçois que init_lc lui donne la valeur NULL. Il faut attendre l'analyse lexicale du fichier d'entrée par le lexeur "lex" pour qu'une adresse lui soit attribuée. Voici la portion de code concernant l'analyse lexicale des données d'entrées utilsitateurs sur les poutres et ressorts: (ce n'est plus du C et c'est peut-être ici que je perds pieds: en espérant que tu connais mieux que moi flex et bison...)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
   /**************element poutre***********************************************/
element_poutre:T_IPOUTRE_ numel connect2 proppou mcvesect list_3reel T_FININS_{
     p_lctelem->typel=TYEL_P_;
     p_lctelem->vectori=base_list_reel[0];
}
   /**************element ressort***********************************************/
element_ressort:T_IRESSORT_ numel connect2 propress T_FININS_{
     p_lctelem->typel=TYEL_RESS_;
     p_lctelem->vectori=base_list_reel[0];
     p_lctelem->connect=base_list_entier[0];
}
   /**************element rigide***********************************************/

base_list_reel est défini ainsi:

Code :

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

static LCTREEL *base_list_reel[NB_BASE_]

Concernant les structures ressort et poutres: En fait, ils sont tous les deux stockés dans des structures de types "elements". Ils ont les mêmes champs. Une fois que toutes les poutres ont été stockées, le programme attaque le stockage des ressorts à la suite. Je pense d'ailleurs que c'est de là que vient le problème: l'adresse "p_lctelem.vectori" est identique depuis le dernier maillon poutre jusqu'au dernier maillon ressort.

**souviron34** · 26/07/2011, 10h52

Envoyé par Anthony_CTI

en espérant que tu connais mieux que moi flex et bison...)

Pas du tout.. Jamais touché.. Tu ferais peut-être mieux d'aller poster sur le forum approprié..

Sinon utilises ddd (ou équivalent) comme debugger, ce sera plus facile de tracer et/ou de remonter le crash..

Code :

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

1
2
3
4
5
6
7
8
9
10
11
   /**************element poutre***********************************************/
element_poutre:T_IPOUTRE_ numel connect2 proppou mcvesect list_3reel T_FININS_{
     p_lctelem->typel=TYEL_P_;
     p_lctelem->vectori=base_list_reel[0];
}
   /**************element ressort***********************************************/
element_ressort:T_IRESSORT_ numel connect2 propress T_FININS_{
     p_lctelem->typel=TYEL_RESS_;
     p_lctelem->vectori=base_list_reel[0];
     p_lctelem->connect=base_list_entier[0];
}

Ne serait-ce pas là ? si jamais les pointeurs base_liste_reel sont les mêmes, on fait afaire à la même valeur, qui ne bouge pas..

**Anthony_CTI** · 26/07/2011, 11h21

C'est fort possible. En fait, dès la sortie de l'analyseur syntaxique flex, l'adresse de vectori est la même de maillons en maillons. Ceci est forcément dû à la mauvaise insertion du nouveau paragraphe concernant les ressorts que tu viens de souligner. En effet, j'ai utilisé base_list_reel[0] pour les ressorts par copier-coller du paragraphe précédent concernant les poutres sans trop savoir ce que je faisais. Inévitablement, ça pardonne pas !. Si les adresses sont les mêmes, la segfault est inévitable car les maillons "elements" sont désalloués un par un dans la suite du programme. Celui-ci tente donc de libérer plusieurs fois la même adresse... Je suis bon pour me replonger dans la logique flex/bison si je veux trouver l'origine du problème.

Merci de m'avoir orienté jusqu'ici

. J'essayerai de trouver des connaisseurs en flex/bison si je ne m'en sors pas.

Conflit d'adresse de champs de liste chaînée

C

Vue hybride

Discussions similaires

Partager

Partager