encore ce segmentation fault 11

Bonsoir tous,
il y a quelques temps de cela je vous avait soumis mon code générant l'erreur; depuis j'ai revu le tout :

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include "carte.h"
 
void setMain_1(void);
struct Carte * getColor(char);
void afficheCombis_1(void);
void afficheCombis_2(void);
void combiBrelan(void);
void combiCarre(int);
void combiSuite(struct Carte *);
void copy(struct Carte *,struct Carte *);
struct Carte *combiCreation(int);
 
struct Carte trefle[14];
struct Carte coeur[14];
struct Carte pique[14];
struct Carte carreau[14];
struct Carte donne[12]={{0,10,' ',0},{1,6,'T',0},{2,13,'K',0},{3,2,'K',0},{4,1,'C',0},{5,1,'P',0},
    {6,10,'C',0},{7,3,'T',0},{8,10,'T',0},{9,8,'K',0},{10,13,'P',0},{11,0,' ',0}};
struct Carte **combinaisons=NULL;int combiCount=1;// stockage dynamique des combinaisons
int totaux[14];// comptage brelans et carrés
 
int main(void) {
 
    while(1) {
        setMain_1();
        combiBrelan();// cherche tous les brelans et carrés composants la main
        // cherche toutes les suites composants la main
        combiSuite(trefle);
        combiSuite(coeur);
        combiSuite(pique);
        combiSuite(carreau);
        afficheCombis_1();
        break;
    }
    return 0;
}
struct Carte *combiCreation(int size) {// crée puis renvoie un pointeur sur un tableau de carte
    struct Carte *cartes = (struct Carte *) malloc((size + 1) * sizeof(struct Carte));
 
    (cartes + size)->rang = 0;// la dernière carte sert de contrôle de fin de tableau
    return cartes;
}
void combiSuite(struct Carte *t) {
    struct Carte *suite;
    int nbCarte = t->rang;
    int i,carteIndex,match = 0;
 
    t++;
    while(((match + nbCarte) > 2) && (nbCarte > 0)) {
        if(t->rang == 0) {// possibilité de suite ...
            if(match > 2) {// confirmation !!!
                suite = combiCreation(match);// création de la suite vide
                carteIndex = 0;
                for(i=1;i<=match;i++) {
                    (suite+carteIndex)->rang = (t-i)->rang;
                    (suite+carteIndex)->color = (t-i)->color;
                    carteIndex++;
                }
                combinaisons = (struct Carte **) realloc(combinaisons,(combiCount+1) * sizeof(struct Carte *));
                combinaisons[combiCount-1] = suite;// copie de la suite dans les combinaisons
                combinaisons[combiCount] = NULL;// dernier pointeur NULL obligatoire
                combiCount++;
            }
            match = 0;
        }
        else {match++;nbCarte--;}
        t++;
    }
    // suite en fin de tableau
    if(match > 2) {
        suite = combiCreation(match);// création de la suite vide
        carteIndex = 0;
        for(i=1;i<=match;i++) {
            (suite+carteIndex)->rang = (t-i)->rang;
            (suite+carteIndex)->color = (t-i)->color;
            carteIndex++;
        }
        combinaisons = (struct Carte **) realloc(combinaisons,(combiCount+1) * sizeof(struct Carte *));
        combinaisons[combiCount-1] = suite;// copie de la suite dans les combinaisons
        combinaisons[combiCount] = NULL;// dernier pointeur NULL obligatoire
        combiCount++;
    }
}
void combiCarre(int ordre) {
    struct  Carte *carre;
 
    carre = combiCreation(4);// création du carré vide
    carre->rang = ordre;carre->color = 'P';
    (carre+1)->rang = ordre;(carre+1)->color = 'C';
    (carre+2)->rang = ordre;(carre+2)->color = 'T';
    (carre+3)->rang = ordre;(carre+3)->color = 'K';
    combinaisons = (struct Carte **) realloc(combinaisons,(combiCount+1) * sizeof(struct Carte *));
    combinaisons[combiCount-1] = carre;// copie du carré dans les combinaisons
    combinaisons[combiCount] = NULL;// dernier pointeur NULL obligatoire
    combiCount++;
}
void combiBrelan(void) {
    int i,index;
    struct  Carte *brelan;
    char *couleurs = "PCKT$",lettre;
 
    for(i=1;i<14;i++) {
        if(totaux[i] == 3) {
            index = 0;
            brelan = combiCreation(3);// création du brelan vide
            if((trefle+i)->rang) {
                (brelan+index)->rang = (trefle+i)->rang;
                (brelan+index)->color = (trefle+i)->color;
                index++;
            }
            if((coeur+i)->rang) {
                (brelan+index)->rang = (coeur+i)->rang;
                (brelan+index)->color = (coeur+i)->color;
                index++;
            }
            if((pique+i)->rang) {
                (brelan+index)->rang = (pique+i)->rang;
                (brelan+index)->color = (pique+i)->color;
                index++;
            }
            if((carreau+i)->rang) {
                (brelan+index)->rang = (carreau+i)->rang;
                (brelan+index)->color = (carreau+i)->color;
                index++;
            }
            combinaisons = (struct Carte **) realloc(combinaisons,(combiCount+1) * sizeof(struct Carte *));
            combinaisons[combiCount-1] = brelan;// copie du brelan dans les combinaisons
            combinaisons[combiCount] = NULL;// dernier pointeur NULL obligatoire
            combiCount++;
        }
        if(totaux[i] == 4) {
            combiCarre(i);
            while((lettre = *couleurs) != '$') {
                brelan = combiCreation(3);// création du brelan vide
                index = 0;
                switch(lettre) {
                    case 'C' :
                        brelan->rang = i;brelan->color = 'P';
                        (brelan+1)->rang = i;(brelan+1)->color = 'K';
                        (brelan+2)->rang = i;(brelan+2)->color = 'T';
                        break;
                    case 'P' :
                        brelan->rang = i;brelan->color = 'C';
                        (brelan+1)->rang = i;(brelan+1)->color = 'K';
                        (brelan+2)->rang = i;(brelan+2)->color = 'T';
                        break;
                    case 'K' :
                        brelan->rang = i;brelan->color = 'P';
                        (brelan+1)->rang = i;(brelan+1)->color = 'C';
                        (brelan+2)->rang = i;(brelan+2)->color = 'T';
                        break;
                    case 'T' :
                        brelan->rang = i;brelan->color = 'P';
                        (brelan+1)->rang = i;(brelan+1)->color = 'K';
                        (brelan+2)->rang = i;(brelan+2)->color = 'C';
                        break;
                    default :
                        fprintf(stdout,"Bad color %c\n",lettre);
                        exit(EXIT_FAILURE);
                }
                combinaisons = (struct Carte **) realloc(combinaisons,(combiCount+1) * sizeof(struct Carte *));
                combinaisons[combiCount-1] = brelan;// copie du brelan dans les combinaisons
                combinaisons[combiCount] = NULL;// dernier pointeur NULL obligatoire
                combiCount++;
                couleurs++;
            }
        }
    }
}
void setMain_1(void) {// range les cartes de la donne par couleur
    int i;
 
    for(i=1;i<=donne[0].rang;i++) {
        copy(donne+i,getColor((donne+i)->color));
        totaux[(donne+i)->rang] += 1;// le nombre de carte de ce rang augmente
    }
}
void copy(struct Carte *c,struct Carte *table) {// copie une carte dans une table
    table->rang++;
    (table+(c->rang))->rang = c->rang;
    (table+(c->rang))->color = c->color;
    (table+(c->rang))->used = c->used;
}
struct Carte * getColor(char c) {// renvoie la table couleur demandée
    switch(c) {
        case 'P' :
            return pique;
        case 'C' :
            return coeur;
        case 'K' :
            return carreau;
        case 'T' :
            return trefle;
        default :
            fprintf(stderr,"bad color '%c' !!",c);
            exit(EXIT_FAILURE);
    }
}
void afficheCombis_1(void) {
    int carteIndex;
 
    fprintf(stdout,"\nCombinaisons trouvees :\n");
    while(combinaisons != NULL) {
        carteIndex = 0;
        while((*combinaisons + carteIndex)->rang != 0) {
            fprintf(stdout,"%d%c ",(*combinaisons + carteIndex)->rang,(*combinaisons + carteIndex)->color);
            carteIndex++;
        }
        combinaisons++;
    }
    fprintf(stdout,"\n");
}
void afficheCombis_2(void) {
    int carteIndex,combiIndex=0;
 
    fprintf(stdout,"\nCombinaisons trouvees :\n");
    while(combinaisons[combiIndex] != NULL) {
        carteIndex = 0;
        while((combinaisons[combiIndex][carteIndex]).rang != 0) {
            fprintf(stdout,"%d%c ",(combinaisons[combiIndex][carteIndex]).rang,(combinaisons[combiIndex][carteIndex]).color);
            carteIndex++;
        }
        combiIndex++;
    }
    fprintf(stdout,"\n");
}

Comme vous pouvez le constater il y a 2 procédure d'affichage (les 2 dernières) ,et voici pourquoi :
Lorsque des combinaisons de carte sont présentes afficheCombis_2() les affiche parfaitement et tout se termine bien mais lorsqu'il n'y a aucune combinaisons
le programme plante !
Mais si j'utilise afficheCombis_1() c'est le contraire qui se produit !!!
Je n'y comprend rien ???

Est-ce que tu as regardé ce qu'un débogueur affiche quand l'erreur survient ?

Non et d'ailleurs je n'en utilise pas ; je sais c'est mal ...
D'habitude quelques fprintf() bien placés suffisent à donner des pistes mais ici j'avoue ne pas saisir la subtilité

Il est donc temps que tu apprennes à utiliser un débogueur.

Tu trouverais alors facilement la cause de la plupart de ces bugs.

Tu utilises quel environnement de développement, quel compilateur, OS, etc. ?

je travaille sur Mac avec Xcode mais j'utilise gcc comme compilateur

En fait j'ai trouvé la solution ; le test du while() externe ne répondait pas à tous les cas de figure ; je l'ai donc changé pour donner :
Code:

1 2 while((combinaisons != NULL) && (combinaisons[combiIndex] != NULL)) { ....
Et ça fonctionne !!

Ah bon, je croyais xcode utilisait CLang plutôt que gcc mais de toute façon, xcode permet de déboguer un programme, c'st la moindre des choses pour un IDE.

Voir par exemple https://mac.developpez.com/cours/Xco...page_8#LVIII-G (même si c'est là de l'objective-C, le principe est le même).

Merci mais trop compliqué pour moi ; tous ces dossiers ,sous dossier ....
Je programme des applis super-light et j'ai pas envie de me coltiner avec des usines à gaz !
Ca me rappelle la programmation Windows avec Visual Studio et les MFC ; des dizaines de pages de lecture sans compter les centaines de fonctions de
programmation.
C'est pas une tête qu'il faut avoir

??

En deux lignes de commande, on arrive a trouver l'origine des SEGFAULT de tes programmes, et avec un ide, il suffit probablement de deux clics de souris.