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