segmentation fault 11

Version imprimable

Bonjour à tous ;
voici le code :

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "carte.h"
#include "fonctions.h"
 
/* La première carte de chaque table sert de compteur de carte dans
   la couleur via son élément 'rang' */
struct Carte trefle[14];
struct Carte coeur[14];
struct Carte pique[14];
struct Carte carreau[14];
struct Carte suites[12];
struct Carte groups[12];
struct Carte nulles[12];
struct Carte donne[12]={{0,10,' ',0},{1,7,'P',0},{2,5,'P',0},{3,6,'P',0},{4,7,'C',0},{5,5,'C',0},
    {6,7,'K',0},{7,8,'K',0},{8,10,'K',0},{9,7,'T',0},{10,12,'C',0},{11,0,' ',0}};
struct Carte **brelanCarre[] = {NULL,NULL,NULL};
struct Carte bestHand[12];
 
int defaultBest=500,nbMains;
int totaux[14];// comptabilisation des brelans et carrés
 
int main(void) {
 
    while(1) {
        setMain_1(0);
        return 0;
    }
}
int checkEntry(int r,char c) {
    if((getColor(c))[r].rang == 0) return 0;
    else return 1;
}
void setMain_1(int level) {
    fprintf(stdout,"\nentre dans setMain() ...");
    nouvelleMain(level);
    setGroup(carreau,trefle,coeur,pique);
    setSuite(coeur);
    setSuite(trefle);
    setSuite(carreau);
    setSuite(pique);
    setNulle(coeur,carreau,trefle,pique);
    fprintf(stdout,"\nsort de setMain().");
}
void nouvelleMain(int level) {
  int i;
 
    fprintf(stdout,"\nentre dans nouvelleMain() ...");
    for(i=0;i<12;i++) {
        suites[i].rang=0;suites[i].color=' ';suites[i].used=0;
        if(groups[i].used == level) {//on efface les carte du niveau uniquement
            groups[i].rang=0;
            groups[i].color=' ';
            groups[i].used=0;
        }
        nulles[i].rang=0;nulles[i].color=' ';nulles[i].used=0;
    }
  for(i=1;i<=donne[0].rang;i++) {
    if(((donne+i)->used > 0) && ((donne+i)->used < level)) continue;
    (donne + i)->used = 0;
    rangeCarte(donne+i);
    totaux[(donne+i)->rang] += 1;
  }
    fprintf(stdout,"\nsort de nouvelleMain().");
}
void rangeCarte(struct Carte *c) {
    fprintf(stdout,"\nentre dans rangeCarte() ...");
    assert(c != NULL);
    copy(c,getColor(c->color));
    fprintf(stdout,"\nsort de rangeCarte().");
}
struct Carte * getColor(char c) {
    fprintf(stdout,"\nentre dans getColor() ...");
    switch(c) {
        case 'P' :
        fprintf(stdout,"\nsort de getColor().");
        return pique;
        case 'C' :
        fprintf(stdout,"\nsort de getColor().");
        return coeur;
        case 'K' :
        fprintf(stdout,"\nsort de getColor().");
        return carreau;
        case 'T' :
        fprintf(stdout,"\nsort de getColor().");
        return trefle;
        default :
        fprintf(stderr,"bad color '%c' !!",c);
        exit(EXIT_FAILURE);
    }
}
int evalLowCost(void) {
  int i,valeur=0;
 
  for(i=nulles[0].rang;i>0;i--) {
    if(nulles[i].rang > 9) valeur += 10;
    else valeur += nulles[i].rang;
  }
  return valeur;
}
void setGroup(struct Carte *t1,struct Carte *t2,struct Carte *t3,struct Carte *t4) {
    int i,count=0;
 
    fprintf(stdout,"\nentre dans setGroups() ...");
    for(i=1;i<14;i++) {
        if(totaux[i] == 3) {
            if((t1+i)->rang) {
                //(t1+i)->used = 2;
                totaux[i]--;t1->rang--;
                copyKill(t1+i,groups);
            }
            if((t2+i)->rang) {
                //(t2+i)->used = 2;
                totaux[i]--;t2->rang--;
                copyKill(t2+i,groups);
            }
            if((t3+i)->rang) {
                //(t3+i)->used = 2;
                totaux[i]--;t3->rang--;
                copyKill(t3+i,groups);
            }
            if((t4+i)->rang) {
                //(t4+i)->used = 2;
                totaux[i]--;t4->rang--;
                copyKill(t4+i,groups);
            }
        }
        else if(totaux[i] == 4) {
            assert(count < 2);// Impossible de posséder plus de 2 carrés parmi 10 cartes
            brelanCarre[count] = carreAnalysis(i);
            count++;
        }
    }
    if(count) traiterCarre(0);
    fprintf(stdout,"\nsort de setGroups().");
}

Le programme compile sans erreur.
Le code de setMain_1() s'exécute ainsi que celui de nouvelleMain() ,puis rangeCarte() getColor() et copy() 10 fois ; alors l'exécution sort de
nouvelleMain() comme l'attestent les fprintf() disséminés dans les fonctions. Ensuite, le programme s'arrête et s'affiche un : Segmentation fault: 11
Est ce qu'on peut m'expliquer ce qu'il se passe exactement ...

10/03/2018, 11h59
jlliagre

Il manque les fichiers .h

Citation:

Envoyé par jlliagre

Il manque les fichiers .h

ok les voici :

Code:

1
2
3
4
5
6
7
8
9
10
 
#ifndef CARTE_H
#define CARTE_H
struct Carte {
    int place;
    int rang;
    char color;
    int used;
};
#endif

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef fonctions_h
#define fonctions_h
 
void setSuite(struct Carte *);
void setGroup(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void setNulle(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void copy(struct Carte *,struct Carte *);
struct Carte **carreAnalysis(int);
struct Carte * getColor(char);
int checkEntry(int,char);
void rangeCarte(struct Carte *);
void setMain_1(int);
void setMain_2(int);
void nouvelleMain(int);
void copyKill(struct Carte *,struct Carte *);
void traiterCarre(int);
void afficheMain(void);
int evalLowCost(void);
 
#endif /* fonctions_h */

Il manque encore beaucoup de code source:

Code:

1
2
3
4
5
6
7
8
9
# gcc -Wall a.c
Symbole                 première référence
 non défini                        dans le fichier
copy                                /var/tmp//cc8laEaV.o
copyKill                            /var/tmp//cc8laEaV.o
traiterCarre                        /var/tmp//cc8laEaV.o
setNulle                            /var/tmp//cc8laEaV.o
setSuite                            /var/tmp//cc8laEaV.o
carreAnalysis                       /var/tmp//cc8laEaV.o

10/03/2018, 15h55
exe2bin

Citation:

Envoyé par jlliagre

Il manque encore beaucoup de code source:

je crois que ce n'est pas important en ce qui concerne le problème ?!
10/03/2018, 17h06
Sve@r

Citation:

Envoyé par exe2bin

Est ce qu'on peut m'expliquer ce qu'il se passe exactement ...

Bonjour

Tu as un comportement indéterminé. En bref tu as une instruction syntaxiquement correcte (donc ça compile sans erreur) mais qui exécute une action illégale ou impossible. Le plus souvent c'est quand on tape dans un pointé non alloué (on tape alors n'importe où dans la mémoire). Cela produit alors un "comportement indéterminé" donc par définition non prévisible (même si statistiquement on a généralement un gros plantage comme celui que tu as).
Et quand je vois struct Carte **brelanCarre[] = {NULL,NULL,NULL}; (un truc en 3D) je me dis que peut-être c'est de ce côté qu'il faudrait investiguer...

Citation:

Envoyé par exe2bin

je crois que ce n'est pas important en ce qui concerne le problème ?!

Ben si un peu quand-même. Parce que si on n'arrive pas à compiler, on n'arrivera pas à reproduire le comportement.
10/03/2018, 20h03
jlliagre

Citation:

Envoyé par exe2bin

je crois que ce n'est pas important en ce qui concerne le problème ?!

Qu'est-ce qui te fais penser que ça n'a pas d'importance pour identifier le problème ? Tu as des infos que tu n'a pas communiqué ? Tu connais sa cause du SEGFAULT ?
11/03/2018, 00h58
exe2bin

Citation:

Envoyé par Sve@r

Bonjour

Tu as un comportement indéterminé. En bref tu as une instruction syntaxiquement correcte (donc ça compile sans erreur) mais qui exécute une action illégale ou impossible. Le plus souvent c'est quand on tape dans un pointé non alloué (on tape alors n'importe où dans la mémoire). Cela produit alors un "comportement indéterminé" donc par définition non prévisible (même si statistiquement on a généralement un gros plantage comme celui que tu as).
Et quand je vois struct Carte **brelanCarre[] = {NULL,NULL,NULL}; (un truc en 3D) je me dis que peut-être c'est de ce côté qu'il faudrait investiguer...

Ben si un peu quand-même. Parce que si on n'arrive pas à compiler, on n'arrivera pas à reproduire le comportement.

Je suis entièrement d'accord là-dessus mais comment expliquer le comportement que tu décris alors même qu'aucune allocation mémoire n'a
lieu avant le plantage du programme puisque celui-ci n'arrive pas jusqu'à la fonction setGroup() ,fonction qui n'est pas encore celle qui alloue
la mémoire ???
11/03/2018, 09h45
Sve@r
Citation:

Envoyé par exe2bin

Je suis entièrement d'accord là-dessus mais comment expliquer le comportement que tu décris alors même qu'aucune allocation mémoire n'a
lieu avant le plantage du programme puisque celui-ci n'arrive pas jusqu'à la fonction setGroup() ,fonction qui n'est pas encore celle qui alloue
la mémoire ???

Ce comportement ne se produit pas qu'à l'allocation. Il peut aussi se produire quand par exemple tu as un tableau de n éléments et que tu vas adresser l'élément [-x] (improbable ? Pas forcément si tu utilises un indice signé et que l'incrément le bascule dans la plage des négatifs) ou bien l'élément [x] avec x >= n.

Prenons par exemple cette petite partie de code
Code:

1 2 3 4 5 6 for(i=1;i<=donne[0].rang;i++) { if(((donne+i)->used > 0) && ((donne+i)->used < level)) continue; (donne + i)->used = 0; rangeCarte(donne+i); totaux[(donne+i)->rang] += 1; }
Tu as un "i" qui va de 1 à "rang" (inclus) et tu l'utilises ensuite comme indice de "donne" (parce que (donne + i)->used ce n'est rien d'autre que donne[i].used en moins lisible et pas plus rapide). Là moi je m'interroge... Un indice de tableau qui commence à 1 ? Qui va jusqu'à une certaine limite mais qui inclus cette limite ??? Ca ressemble fort à un int tab[10]; for (i=1; i <= 10; i++) tab[i]=... typique de l'erreur de débutant et qui conduit au comportement indéterminé.

Je ne dis pas que l'erreur est là (ce n'est pas à moi de vérifier ton code) mais c'est ce genre de cas qu'il faut vérifier.

PS: pourquoi (donne + i)->used n'est pas plus rapide que donne[i].used ? Parce que dans les deux cas l'opération est la même. Certes on dit que passer par un pointeur est plus rapide que passer par un indice... mais c'est à la condition d'avoir un pointeur déjà à la bonne position. Comme par exemple
Code:

1 2 3 4 5 6 for(i=1, pt=donne;i<=donne[0].rang;i++, pt++) { if((pt->used > 0) && (pt->used < level)) continue; pt->used = 0; rangeCarte(pt); totaux[pt->rang] += 1; }
Là effectivement ça a du sens. Parce que la valeur "donne + i" calculée 5 fois dans ton code n'est calculée qu'une fois dans le mien.
11/03/2018, 13h55
exe2bin

Tout d'abord merci de répondre; tout cela est certain . Au début de la conception je voulais ne faire appel qu'aux tableaux mais l'analyse des carrés
ainsi que des brelans afférent imposant un certains nombre de combinaison ma convaincu d'utiliser la récursivité associée aux pointeurs de pointeurs
de carte ....
Cela dit, dans le cas qui me préoccupe, je vise en premier lieu à faire fonctionner le programme avant d'essayer de le rendre plus performant; en ce
qui concerne la boucle, elle ne peut engendrer d'indice <0 ni même >11 (car c'est la valeur du dernier indice du tableau donne) étant donné que
donne[0].rang = 10 comme tu pourras le constater (codé en dur dans la définition du tableau). I prend effectivement la valeur 1 initiale car l'indice
zéro est réservé au comptage des cartes de la main (10 ou 11).
11/03/2018, 15h17
jlliagre

Plutôt que d'essayer de démontrer qu'il n'y a pas de problèmes dans ton code, envoie les fichiers qui manquent pour que l'on puisse reproduire l'erreur. Ce sera plus productif...

Ok !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#ifndef fonctions_h
#define fonctions_h
 
void setSuite(struct Carte *);
void setGroup(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void setNulle(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void copy(struct Carte *,struct Carte *);
struct Carte **carreAnalysis(int);
struct Carte * getColor(char);
int checkEntry(int,char);
void rangeCarte(struct Carte *);
void setMain_1(int);
void setMain_2(int);
void nouvelleMain(int);
void copyKill(struct Carte *,struct Carte *);
void traiterCarre(int);
void afficheMain(void);
int evalLowCost(void);
 
#endif /* fonctions_h */

Code:

1
2
3
4
5
6
7
8
9
10
 
#ifndef CARTE_H
#define CARTE_H
struct Carte {
    int place;
    int rang;
    char color;
    int used;
};
#endif

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "carte.h"
//#include "fonctions.h"
int checkEntry(int,char);
void rangeCarte(struct Carte *);
struct Carte * getColor(char);
void copy(struct Carte *,struct Carte *);
void copyKill(struct Carte *,struct Carte *);
struct Carte **carreAnalysis(int);
void setNulle(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
void setSuite(struct Carte *);
void traiterCarre(int);
void afficheMain(void);
void nouvelleMain(int);
int evalLowCost(void);
void setMain_1(int);
void setGroup(struct Carte *,struct Carte *,struct Carte *,struct Carte *);
struct Carte trefle[14];
struct Carte coeur[14];
struct Carte pique[14];
struct Carte carreau[14];
struct Carte suites[12];
struct Carte groups[12];
struct Carte nulles[12];
struct Carte donne[12]={{0,10,' ',0},{1,7,'P',0},{2,5,'P',0},{3,6,'P',0},{4,7,'C',0},{5,5,'C',0},
    {6,7,'K',0},{7,8,'K',0},{8,10,'K',0},{9,7,'T',0},{10,12,'C',0},{11,0,' ',0}};
struct Carte **brelanCarre[] = {NULL,NULL,NULL};
struct Carte bestHand[12];
 
int defaultBest=500,nbMains;
int totaux[14];
 
int main(void) {
 
    while(1) {
        setMain_1(0);
        return 0;
    }
}
int checkEntry(int r,char c) {
    if((getColor(c))[r].rang == 0) return 0;
    else return 1;
}
void setMain_1(int level) {
    fprintf(stdout,"\nentre dans setMain() ...");
    nouvelleMain(level);
    setGroup(carreau,trefle,coeur,pique);
    fprintf(stdout,"\nsort de setMain().");
}
void nouvelleMain(int level) {
  int i;
 
    fprintf(stdout,"\nentre dans nouvelleMain() ...");
    for(i=0;i<12;i++) {
        suites[i].rang=0;suites[i].color=' ';suites[i].used=0;
        if(groups[i].used == level) {//on efface les carte du niveau uniquement
            groups[i].rang=0;
            groups[i].color=' ';
            groups[i].used=0;
        }
        nulles[i].rang=0;nulles[i].color=' ';nulles[i].used=0;
    }
  for(i=1;i<=donne[0].rang;i++) {
    if(((donne+i)->used > 0) && ((donne+i)->used < level)) continue;
    (donne + i)->used = 0;
    rangeCarte(donne+i);
    totaux[(donne+i)->rang] += 1;
  }
    fprintf(stdout,"\nsort de nouvelleMain().");
}
void rangeCarte(struct Carte *c) {
    fprintf(stdout,"\nentre dans rangeCarte() ...");
    assert(c != NULL);
    copy(c,getColor(c->color));
    fprintf(stdout,"\nsort de rangeCarte().");
}
struct Carte * getColor(char c) {
    fprintf(stdout,"\nentre dans getColor() ...");
    switch(c) {
        case 'P' :
        fprintf(stdout,"\nsort de getColor().");
        return pique;
        case 'C' :
        fprintf(stdout,"\nsort de getColor().");
        return coeur;
        case 'K' :
        fprintf(stdout,"\nsort de getColor().");
        return carreau;
        case 'T' :
        fprintf(stdout,"\nsort de getColor().");
        return trefle;
        default :
        fprintf(stderr,"bad color '%c' !!",c);
        exit(EXIT_FAILURE);
    }
}
int evalLowCost(void) {
  int i,valeur=0;
 
  for(i=nulles[0].rang;i>0;i--) {
    if(nulles[i].rang > 9) valeur += 10;
    else valeur += nulles[i].rang;
  }
  return valeur;
}
void setGroup(struct Carte *t1,struct Carte *t2,struct Carte *t3,struct Carte *t4) {
    int i,count=0;
 
    fprintf(stdout,"\nentre dans setGroups() ...");
    for(i=1;i<14;i++) {
        if(totaux[i] == 3) {
            if((t1+i)->rang) {
                totaux[i]--;t1->rang--;
                copyKill(t1+i,groups);
            }
            if((t2+i)->rang) {
                totaux[i]--;t2->rang--;
                copyKill(t2+i,groups);
            }
            if((t3+i)->rang) {
                totaux[i]--;t3->rang--;
                copyKill(t3+i,groups);
            }
            if((t4+i)->rang) {
                totaux[i]--;t4->rang--;
                copyKill(t4+i,groups);
            }
        }
        else if(totaux[i] == 4) {
            assert(count < 2);// Impossible de posséder plus de 2 carrés parmi 10 cartes
            brelanCarre[count] = carreAnalysis(i);
            count++;
        }
    }
    if(count) traiterCarre(0);
    fprintf(stdout,"\nsort de setGroups().");
}
void copy(struct Carte *c,struct Carte *table) {
    fprintf(stdout,"\nentre dans copy() ...");
    table->rang++;
    (table+(c->rang))->rang = c->rang;
    (table+(c->rang))->color = c->color;
    (table+(c->rang))->used = c->used;
    fprintf(stdout,"\nsort de copy() ...");
}
void traiterCarre(int index) {
    int nBrelan=0,nCarte,handValue,i,j;
    struct Carte *family;
 
    while(brelanCarre[index][nBrelan]) {
        nCarte = 0;
        while((i = (brelanCarre[index][nBrelan] + nCarte)->rang)) {
            family = getColor((brelanCarre[index][nBrelan] + nCarte)->color);
            (family + i)->used = index;// marquage de la carte dans groups et donne
            donne[(family + i)->place].used = index;// selon le niveau
            totaux[i]--;family->rang--;
            copyKill(family + i,groups);
            nCarte++;
        }
        if(brelanCarre[index+1]) {
            traiterCarre(index+1);
        }
        else {
            setSuite(coeur);
            setSuite(trefle);
            setSuite(carreau);
            setSuite(pique);
            setNulle(coeur,carreau,trefle,pique);
            handValue = evalLowCost();
            if(handValue < defaultBest) {
                for(j=nulles[0].rang;j>0;j--) copyKill(nulles + j,bestHand);
                defaultBest = handValue;
            }
        }
        afficheMain();
        setMain_1(index);
        nBrelan++;
    }
}
void afficheMain(void) {
    int i;
 
    fprintf(stdout,"\nsuite: ");
    for(i=suites[0].rang;i>0;i--) fprintf(stdout,"%d%c ",suites[i].rang,suites[i].color);
    fprintf(stdout,"\ngroups: ");
    for(i=groups[0].rang;i>0;i--) fprintf(stdout,"%d%c ",groups[i].rang,groups[i].color);
    fprintf(stdout,"\nnulles: ");
    for(i=nulles[0].rang;i>0;i--) fprintf(stdout,"%d%c ",nulles[i].rang,nulles[i].color);
}

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
121
122
123
124
125
 
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "carte.h"
#include "fonctions.h"
 
extern struct Carte trefle[];
extern struct Carte coeur[];
extern struct Carte pique[];
extern struct Carte carreau[];
extern int totaux[];
extern int defaultBest;
extern struct Carte suites[];
extern struct Carte groups[];
extern struct Carte nulles[];
extern struct Carte donne[];
extern struct Carte bestHand[];
extern struct Carte **brelanCarre[];
 
void setNulle(struct Carte *t1,struct Carte *t2,struct Carte *t3,struct Carte *t4) {
  int i;
 
  for(i=1;i<14;i++) {
    if((t1+i)->rang) {
      totaux[i]--;t1->rang--;
      copyKill(t1+i,nulles);
    }
    if((t2+i)->rang) {
      totaux[i]--;t2->rang--;
      copyKill(t2+i,nulles);
    }
    if((t3+i)->rang) {
      totaux[i]--;t3->rang--;
      copyKill(t3+i,nulles);
    }
    if((t4+i)->rang) {
      totaux[i]--;t4->rang--;
      copyKill(t4+i,nulles);
    }
  }
}
void setSuite(struct Carte *t) {
  struct Carte *t0 = t;
  int nbCarte = t->rang;
  int i,match = 0;
 
    fprintf(stdout,"\nentre dans setSuite() ...");
  t++;
  while(((match + nbCarte) > 2) && (nbCarte > 0)) {
    if(t->rang == 0) {// suite trouvée
      if(match > 2) {
          for(i=1;i<=match;i++) {
              t0->rang--;totaux[(t-i)->rang]--;
              copyKill(t-i,suites);
          }
      }
      match = 0;
    }
    else {match++;nbCarte--;}
    t++;
  }
  if(match > 2) {
    for(i=1;i<=match;i++) {
      t0->rang--;totaux[(t-i)->rang]--;
      copyKill(t-i,suites);
    }
  }
    fprintf(stdout,"\nsort de setSuite().");
}
void copyKill(struct Carte *c,struct Carte *table) {
    fprintf(stdout,"\nentre dans copyKill() ...");
  table->rang++;
  (table+(table->rang))->rang = c->rang;
  (table+(table->rang))->color = c->color;
  (table+(table->rang))->used = c->used;
  c->used=0;c->color=' ';c->rang=0;
    fprintf(stdout,"\nsort de copyKill().");
}
struct Carte ** brelanAnalysis(struct Carte **c,int ordre) {
    int i=1;
    char *couleurs = "PCKT$",lettre;
    c = (struct Carte **) realloc(c,6 * sizeof(struct Carte *));
    while((lettre = *couleurs) != '$') {
        c[i] = (struct Carte *) malloc(4 * sizeof(struct Carte));
        switch(lettre) {
            case 'C' :
                c[i]->rang=ordre;c[i]->color='K';c[i]->used=0;
                (c[i]+1)->rang=ordre;(c[i]+1)->color='T';(c[i]+1)->used=0;
                (c[i]+2)->rang=ordre;(c[i]+2)->color='P';(c[i]+2)->used=0;
                break;
            case 'P' :
                c[i]->rang=ordre;c[i]->color='K';c[i]->used=0;
                (c[i]+1)->rang=ordre;(c[i]+1)->color='T';(c[i]+1)->used=0;
                (c[i]+2)->rang=ordre;(c[i]+2)->color='C';(c[i]+2)->used=0;
                break;
            case 'K' :
                c[i]->rang=ordre;c[i]->color='C';c[i]->used=0;
                (c[i]+1)->rang=ordre;(c[i]+1)->color='T';(c[i]+1)->used=0;
                (c[i]+2)->rang=ordre;(c[i]+2)->color='P';(c[i]+2)->used=0;
                break;
            case 'T' :
                c[i]->rang=ordre;c[i]->color='K';c[i]->used=0;
                (c[i]+1)->rang=ordre;(c[i]+1)->color='C';(c[i]+1)->used=0;
                (c[i]+2)->rang=ordre;(c[i]+2)->color='P';(c[i]+2)->used=0;
                break;
            default :
                fprintf(stdout,"Bad color %c\n",lettre);
                exit(EXIT_FAILURE);
        }
        i++;couleurs++;
    }
    return c;
}
struct Carte ** carreAnalysis(int ordre) {
    struct Carte **c = NULL;
    c = (struct Carte **) malloc(sizeof(struct Carte *));
    c[0] = (struct Carte *) malloc(5 * sizeof(struct Carte));
    c[0]->rang=ordre;c[0]->color='P';c[0]->used=0;
    (c[0]+1)->rang=ordre;(c[0]+1)->color='C';(c[0]+1)->used=0;
    (c[0]+2)->rang=ordre;(c[0]+2)->color='K';(c[0]+2)->used=0;
    (c[0]+3)->rang=ordre;(c[0]+3)->color='T';(c[0]+3)->used=0;
    c = brelanAnalysis(c,ordre);
    return 0;
}

Voilà

11/03/2018, 18h11
jlliagre

Sve@r avait vu juste :

Citation:

Et quand je vois struct Carte **brelanCarre[] = {NULL,NULL,NULL}; (un truc en 3D) je me dis que peut-être c'est de ce côté qu'il faudrait investiguer...

Ton code essaie de déréférencer un pointeur nul à cette instruction (index vaut 0):

Code:

152 while(brelanCarre[index][nBrelan]) {
11/03/2018, 19h50
exe2bin
Il y a quand même quelque chose qu'il faut m'expliquer :
La ligne fautive se trouve dans la procédure traiterCarre() qui est appelée par la fonction setGroup() ; comment comprendre alors que la ligne
Code:

1 2 fprintf(stdout,"\nentre dans setGroups() ...");
au début de setGroup() n'affiche aucun message sur ma console ??
11/03/2018, 20h21
Sve@r
Citation:

Envoyé par jlliagre

Sve@r avait vu juste

Juste la chance :aie:
C'est vrai que c'était le type le plus complexe donc qui avait le plus de probabilités de foutre le truc en vrac mais bon, je n'ai pas examiné le code quand j'ai émis cette hypothèse 8-)
Citation:
Envoyé par exe2bin

La ligne fautive se trouve dans la procédure traiterCarre() qui est appelée par la fonction setGroup() ; comment comprendre alors que la ligne

Code:

1 2 fprintf(stdout,"\nentre dans setGroups() ...");

au début de setGroup() n'affiche aucun message sur ma console ??
Ah ça ce sont les joies de la bufferisation.
Quand tu envoies des infos dans un flux (fichier, écran), les infos sont bufferisées. Et le buffer n'est vidé (et les infos arrivent réellement dans le flux) que dans 4 cas
1. quand le buffer est plein
2. quand le programme se termine (quand il se termine correctement s'entend, et non quand il se plante comme un roseau)
3. quand on demande explicitement un vidage via fflush().
4. quand le bouzin qui traite les infos rencontre un caractère '\n'
Donc quand tu arrives à fprintf(stdout,"\nentre dans setGroups() ..."), le bouzin rencontre un '\n' et vide donc à l'écran tout ce qui se trouve dans le buffer (qui avait donc été écrit avant cette ligne)... mais comme ensuite il n'y a rien qui spécifie qu'il faut revider ce qui vient d'y être mis, laisse donc le buffer intact avec le reste de la ligne à l'intérieur. Puis le programme plante et donc plus rien. Et toi, tu crois que ça a planté avant cette instruction puisque tu ne l'as pas vue concrètement s'exécuter.

Moi dans ton code (que j'ai pu enfin compiler !!!), j'ai inversé les '\n' et je les ai tous placés après le texte. Et j'ai donc bien vu apparaitre

Citation:

...
sort de copy() ...
sort de rangeCarte().
sort de nouvelleMain().
entre dans setGroups() ...
Erreur de segmentation

.

Donc pour débugguer, soit tu mets tes '\n' en fin de chaine, soit tu rajoutes fflush(stdout) juste après tes fprintf(), soit tu remplaces toute instruction fprintf(stdout, chaine) par write(1, chaine, strlen(chaine)) (mode bas niveau sans bufferisation).

Mais bon, en dehors de toute ironie, chapeau pour la qualité de ton code. Effectivement il a compilé nickel avec zéro warning. Au-moins (après avoir galéré pour l'obtenir) je n'ai pas eu à me casser le bec sur 3000 warnings.
11/03/2018, 21h19
exe2bin

Merci pour ta science Sve@r ;
au fait, si tu pouvais me dire ce que tu as changé .... :oops:
11/03/2018, 23h16
Sve@r

Citation:

Envoyé par exe2bin

au fait, si tu pouvais me dire ce que tu as changé .... :oops:

Pour ton segfault ? Rien. Ton programme plante aussi chez-moi.

Pour les messages ? J'ai remplacé tous les fprintf(stdout, "\n.......") par fprintf(stdout, ".......\n"). Sous "vi" ça se fait d'un coup en tapant :g/stdout,"\\n\(.\{1,\}\)"/s//stdout,"\1\\n"/g. Ca signifie "en remplacement global" (:g), toute chaine contenant "stdout" puis un guillemet suivi de \n suivi d'un caractère quelconque répété de 1 à n fois et continué par un guillemet (stdout,"\\n.\{1,\}") où je mémorise lesdits caractères dans le premier buffer de "vi" \(...truc à mémoriser...\) ; je remplace le tout (/s//) par "stdout" suivi de guillemets suivi de la chaine mémorisée en buffer "1" puis \n puis des guillemets (stdout,"\1\\n").
12/03/2018, 13h41
exe2bin

J'ai trouvé !!! Ce matin à 5h30, à peine réveillé ... mes yeux se sont négligemment posés sur la faute.
Grand merci à tous.