probleme de delete dans un destructeur

Version imprimable

Bonjour,

Je suis en train de faire un jeu de dames, et lorsque j'essaye de détruire un damier (tableau de 50 cases en mémoire), j'obtiens une seg fault du type:

Code:

1
2
3
4
5
6
7
8
9
10
11
| |b| |b| |b| |b| |b| 10
|b| |b| |b| |b| |b| | 9
| |b| |b| |b| |b| |b| 8
|b| |b| |b| |b| |-| | 7
| |-| |-| |-| |-| |b| 6
|-| |-| |-| |w| |-| | 5
| |w| |w| |-| |w| |w| 4
|w| |w| |w| |w| |w| | 3
| |w| |w| |w| |w| |w| 2
|w| |w| |w| |w| |w| | 1
 a b c d e f g h i j

Entrez le numero d'un coup parmi la liste des coups possibles:

0: e3f4
1: g3f4
2: b4a5
3: b4c5
4: d4c5
5: d4e5
6: h4i5
7: j4i5
8: g5h6
9: g5f6
99
free(): invalid pointer 0x60000fffffffb2b0!
free(): invalid pointer 0x60000fffffffb220!

à la sortie du programme; je n'y comprend pas grand chose.
Code utile:

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
 
 
#ifndef _PLATEAU
#define _PLATEAU
 
// valeur d'une dame
#define VD 2 
 
#include "Coup.h"
#include <iostream>
#include <vector>
 
/*Stockage du plateau */
 
class Plateau {
public:
 
    // Constructeur : Mise en place de la configuration initiale
    Plateau();
 
    // Constructeur de recopie
    Plateau(const Plateau& p);
 
    // Construction du plateau a partir d'un fichier 
    Plateau(char* name);
 
    // écriture de la position courante dans un fichier
    void writeToFile(char* name);
 
    // accès à une case du tableau représentant le plateau 
    short operator[](int i) const {
          return damier[i];
    }
 
    // accès à la valeur du jeu
    int getVal() const {
          return val;
    }
 
    // avancée d'un coup sans supprimer le pion du plateau dans le cas d'une prise
    void ghostMove(const Coup& cp);
 
    // recul d'un coup (memes conditions que ci-dessus)
    void ghostUndo();
 
    // avancée d'un coup
    void move(const Coup& cp);
 
    // recul d'un coup
    void undo();
 
    // ajoute les pions pris dans le cas d'une entrée de coup
    Coup decoreCoup(Coup cp);
 
    // indique si une position est dynamique (ie: pions en prise) ou statique
    bool isStatic(int nbCoups);
 
   // évaluation statique d'une position
   int evalPos(); 
 
   // stockage de la partie dans un fichier
    void stockePartie(char* name);
 
    // lit des coups dans un fichier en les executant au fur et a mesure
    void jouePartie(char* name);
 
   // destructeur
   ~Plateau() {
         delete []damier; // PROVOQUE UNE SEGFAULT (??? pkoi ???)
   } 
 
private:   
 
  // Stockage du plateau : 
  short damier[50];
 
  // vecteur de coups representant la partie via les differents coups joues 
  std::vector<Coup> partie;
 
  // variable globale memorisant la valeur du jeu, dames=VD et pions=1 au début 
  int val; // + si avantage blanc, - si avantage noir 
 
};
 
// Affichage du plateau
extern std::ostream& operator<<(std::ostream& o, const Plateau& p);
 
#endif

Merci d'avance!

10/03/2006, 14h10
Gandalf

Damier est un attribut de ta classe, il est inutilde de le detruire...

d'une manière générale la libération d'une ressource va de pair avec sa reservation. Ici tu ne reserve jamais de place pour Damier, tu n'as donc à liberer cette place.
10/03/2006, 15h23
Chewbi

OK.. Donc en gros lorsque je fais un Truc truc=new Truc(..), il faut un delete truc, si c'est un tableau il faut delete [], et si on a des tableaux genre malloc(n*sizeof(..)) membres d'une classe on n'a pas besoin de les libérer (c'est fait automatiquement?)
10/03/2006, 15h39
Laurent Gomila

Non, un malloc doit être suivi d'un free. Mais malloc est inapproprié en C++.
http://c.developpez.com/faq/cpp/?pag...S_pourquoi_new

A part ça, on peut voir ton code plutôt que les déclarations ?

Je poste le code des classes Coup,Plateau, IterateurCoup [attention code assez longuet] et TrouveCoup (les tests utilisent surtout les trois dernières classes, aux comportements assez parlant suivant le nom). Je me demande bien d'où vient cette seg fault (j'avais le meme type de pb lorsque j'avais essayé de programmer un jeu d'échecs en java :-/)

Coup:

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
 
 
#ifndef _COUP
#define _COUP
 
#include <iostream>
#include <vector>
 
// structure utilisée pour stocker les pions pris
typedef struct Cell {
   	short pion;
   	short type; // VD pour dame blanche..etc; on a besoin de ça pour revenir en arrière dans la partie
} Prise; 
 
class Coup {
 
public:
 
       // constructeur vide
       Coup() {
              dame=false;
       }
 
       // constructeur a partir d'une unique case
       Coup(short p) {   
              dame=false;  
              cases.push_back(p); 
       }
 
       // constructeur prenant en paramètre deux cases
       Coup(short p1, short p2);
 
       // constructeur par recopie 
       Coup(const Coup& cp);
 
       // initialisation du champ "dame" indiquant si le coup donne lieu à une promotion
       void setDame(bool b) {
           dame=b;
       }
 
       // acces à ce champ
       bool getDame() const {
           return dame;
       } 
 
       // méthode ajoutant un nouveau déplacement au coup courant
       void addCase(short p) {
           cases.push_back(p);
       } 
 
       // méthode ajoutant un nouveau pion pris au coup courant
       void addPrise(short pion, short type);
 
       // renvoie en lecture seule les premières et dernières cases de déplacement
       short getFirst() const {
              return cases[0];
       }
       short getLast() const {
              return cases[cases.size()-1];
       }
 
       // renvoie en lecture seule les pions pris au cours du déplacement
       std::vector<Prise> getPrises() const {
              return prises;
       }
 
       // teste si un pion a déjà été pris par le coup courant
       bool testPrise(short pion);
 
       // renvoie en lecture seule les cases de déplacement
       std::vector<short> getCases() const {
              return cases;
       }
 
       // renvoie la chaine de caracteres associee a un coup (pour la sauvegarde d'une partie)
	char* getString();
 
       // destructeur (rien à faire car pas de création explicite de pointeur)
       ~Coup() {}
 
private:
 
       // indique si le coup donne lieu à une promotion en dame
       bool dame; 
 
       // attribut décrivant les cases parcourues               
       std::vector<short> cases;
 
       // attribut décrivant les coordonnées des pions capturés sur le parcours 
       std::vector<Prise> prises; 
 
};
 
// lecture d'un coup à partir d'un flux 
extern std::istream& operator>>(std::istream& i, Coup& cp);
 
// écriture d'un coup à partir d'un flux 
extern std::ostream& operator<<(std::ostream& o, const Coup &cp);
 
// renvoie le coup associe a une chaine de caracteres (pour l'affichage d'une partie)
extern Coup getCoup(std::string s);
 
#endif
 
// Classe pour représenter, afficher, jouer.. un coup
 
#include <iostream>
#include "Coup.h"
 
       // constructeur prenant en paramètre deux cases (on ajoutera les pions pris ailleurs..)
       Coup::Coup(short p1, short p2) {  
              dame=false;               
              cases.push_back(p1);
              cases.push_back(p2);
       }
 
       // constructeur par recopie
       Coup::Coup(const Coup& cp) {
              dame=cp.getDame(); // ATTENTION: quand on fait un push_back(cp), c'est une copie qu'on utilise; donc il faut initialiser dame         
              cases.clear();
              prises.clear();
              for (int i=0; i<(int)cp.getCases().size(); i++) cases.push_back(cp.getCases()[i]); 
              for (int i=0; i<(int)cp.getPrises().size(); i++) prises.push_back(cp.getPrises()[i]); 
       }                 
 
       // méthode ajoutant un nouveau pion pris au coup courant
       void Coup::addPrise(short pion, short type) {
              Prise prise;
	      prise.pion=pion;
	      prise.type=type; 
              prises.push_back(prise);
       }
 
       // teste si un pion a déjà été pris par le coup courant
       bool Coup::testPrise(short pion) {
              for (int i=prises.size()-1; i>=0; i--) 
                  if (prises[i].pion==pion) return true;
	      return false;
       }
 
       // renvoie la chaine de caracteres associee a un coup (pour la sauvegarde d'une partie)
       char* Coup::getString() { 
           char* res=(char*)malloc(2*cases.size()*sizeof(char));
	   short tmp,ligne;
	   char col;
	   for (int i=0; i<(int)cases.size(); i++) {
      	       tmp=cases[i];
	       ligne=tmp/5; 
	       col='a'+ligne%2+2*(tmp%5);  
               *(res+2*i)=col; 
	       *(res+2*i+1)=(char)('0'+ligne);
	   } 
	   return res;   
        }
 
       // redéfinition des opérateurs d'entrée/sortie pour respecter le format proposé:
       std::istream& operator>>(std::istream& i, Coup& cp) { 
           // lecture du coup          
           char c,l;
           std::string s; 
	   i >> s; 
	   c=s[0];
           l=s[1]; 
           cp.addCase((l-'0')*5+(c-'a')/2); 
	   int j=2;
           while (j<(int)s.size()) {
               // lignes et colonnes initialisées  
               c=s[j];
               l=s[j+1]; 
               cp.addCase((l-'0')*5+(c-'a')/2);
		// probleme ici: comment recuperer les types des pions pris? on n'a pas acces au plateau, donc: 
               // on les remplira plus tard!
		j+=2;
	   } 
	   return i;
       }
 
       std::ostream& operator<<(std::ostream& o, const Coup& cp) {
	   // Ecriture du coup:
           short ligne,tmp;
	   char col;
	   for (int i=0; i<(int)cp.getCases().size(); i++) {
      	       tmp=cp.getCases()[i];
	       ligne=tmp/5;
	       col='a'+ligne%2+2*(tmp%5);
               o << col << ligne+1; // ajoute les coordonnées de la position courante dans o
	   }
	   return o;
       }
 
       // renvoie le coup associe a une chaine de caracteres (pour l'affichage d'une partie)
	Coup getCoup(std::string s) { 
	   Coup cp=Coup();
	   // lecture du coup          
           char c,l;
	   c=s[0];
           l=s[1]; 
           cp.addCase((l-'0')*5+(c-'a')/2); 
	   int j=2;
           while (j<(int)s.size()) {
               // lignes et colonnes initialisées  
               c=s[j];
               l=s[j+1]; 
               cp.addCase((l-'0')*5+(c-'a')/2);
		// probleme ici: comment recuperer les types des pions pris? on n'a pas acces au plateau, donc: 
               // on les remplira plus tard!
		j+=2;
	   }
	   return cp;
	}

Plateau:

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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
 
 
#ifndef _PLATEAU
#define _PLATEAU
 
// valeur d'une dame
#define VD 2 
 
#include "Coup.h"
#include <iostream>
#include <vector>
 
/*Stockage du plateau */
 
class Plateau {
public:
 
    // Constructeur : Mise en place de la configuration initiale
    Plateau();
 
    // Constructeur de recopie
    Plateau(const Plateau& p);
 
    // Construction du plateau a partir d'un fichier 
    Plateau(char* name);
 
    // écriture de la position courante dans un fichier
    void writeToFile(char* name);
 
    // accès à une case du tableau représentant le plateau 
    short operator[](int i) const {
          return damier[i];
    }
 
    // accès à la valeur du jeu
    int getVal() const {
          return val;
    }
 
    // avancée d'un coup sans supprimer le pion du plateau dans le cas d'une prise
    void ghostMove(const Coup& cp);
 
    // recul d'un coup (memes conditions que ci-dessus)
    void ghostUndo();
 
    // avancée d'un coup
    void move(const Coup& cp);
 
    // recul d'un coup
    void undo();
 
    // ajoute les pions pris dans le cas d'une entrée de coup
    Coup decoreCoup(Coup cp);
 
    // indique si une position est dynamique (ie: pions en prise) ou statique
    bool isStatic(int nbCoups);
 
   // évaluation statique d'une position
   int evalPos(); 
 
   // stockage de la partie dans un fichier
    void stockePartie(char* name);
 
    // lit des coups dans un fichier en les executant au fur et a mesure
    void jouePartie(char* name);
 
   // destructeur
   ~Plateau() {} 
 
private:   
 
  // Stockage du plateau : 
  short damier[50];
 
  // vecteur de coups representant la partie via les differents coups joues 
  std::vector<Coup> partie;
 
  // variable globale memorisant la valeur du jeu, dames=VD et pions=1 au début 
  int val; // + si avantage blanc, - si avantage noir 
 
};
 
// Affichage du plateau
extern std::ostream& operator<<(std::ostream& o, const Plateau& p);
 
#endif
 
// Classe pour représenter le plateau de jeu
 
#include <iostream>
#include <fstream>
#include "Coup.h"
#include "Plateau.h" 
 
    // Constructeur : Mise en place de la configuration initiale
    Plateau::Plateau() {
        int i;
        for (i=19; i>=0; i--) damier[i]=1;
        for (i=20; i<30; i++) damier[i]=0;
        for (i=30; i<50; i++) damier[i]=-1;
        val=0; 
    } 
 
    // Constructeur de recopie; 
    Plateau::Plateau(const Plateau& p) {
    	val=0;
    	for (int i=49; i>=0; i--) {
        	damier[i]=p[i];
		val+=p[i]; 
        }  
    }
 
    // construction à partir d'un fichier; ATTENTION: dans ce cas on a "oublié" le début de la partie
    // comme dans les logiciels du commerce :)
    Plateau::Plateau(char* name) {
        std::ifstream file(name); 
        if (!file) {
            std::cout << "erreur lors de l'ouverture du fichier " << name << std::endl;
            return;
        }
        char* ch=(char*)malloc(60*sizeof(char));
        file.read(ch,60); // lecture des 50 caractères utiles que l'on place dans ch
        file.close();  
        val=0;
	int j=49;
        for (int i=0; i<60; i++) 
            switch (ch[i]) {
            	case 'W': val+=VD; damier[j-2*(j%5)+4]=VD; j--; break;
                case 'w': val++; damier[j-2*(j%5)+4]=1; j--; break;
                case 'b': val--; damier[j-2*(j%5)+4]=-1; j--; break;
                case 'B': val+=VD; damier[j-2*(j%5)+4]=-VD; j--; break;
                case ' ': damier[j-2*(j%5)+4]=0; j--; break;
                default: break; // cas d'un retour a la ligne
            }   
    }
 
    // écriture de la position courante dans un fichier
    void Plateau::writeToFile(char* name) {
        std::ofstream file(name); 
        if (!file) {
            std::cout << "erreur lors de l'ouverture du fichier " << name << std::endl;
            return;
        }
        file.clear();
        // lecture des 50 caractères utiles que l'on place dans le fichier
        for (int i=49; i>=0; i--) {
            switch (damier[i-2*(i%5)+4]) {
            	case VD: file.put('W'); break;
                case 1: file.put('w'); break;
                case -1: file.put('b'); break;
                case -VD: file.put('B'); break;
                case 0: file.put(' '); break;
                default: break;
            } 
	    if (i%5==0) file.put('\n');
	} 
        file.close(); 
    }  
 
 
    // avancée d'un coup sans supprimer le pion du plateau dans le cas d'une prise
    void Plateau::ghostMove(const Coup& cp) { 
         if (damier[cp.getFirst()]>0) {
             if (cp.getFirst()!=cp.getLast()) { 
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getLast()<45) damier[cp.getLast()]=damier[cp.getFirst()];
                else damier[cp.getLast()]=VD; // promotion en dame
                damier[cp.getFirst()]=0; 
             }
         }
         else { 
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getLast()>=5) damier[cp.getLast()]=damier[cp.getFirst()];
                else damier[cp.getLast()]=-VD; // promotion en dame
                damier[cp.getFirst()]=0;
             }
         } 
         // ajout du coup dans la liste
         partie.push_back(cp);  
    }
 
    // recul d'un coup (memes conditions que ci-dessus)
    void Plateau::ghostUndo() { 
         if (partie.empty()) return; // il faut qu'il y ait au moins un coup à annuler!
         Coup cp=partie.back(); 
         if (damier[cp.getLast()]>0) {
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getDame()) damier[cp.getFirst()]=1;
                else damier[cp.getFirst()]=damier[cp.getLast()];
                damier[cp.getLast()]=0;
             }
         }
         else {
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getDame()) damier[cp.getFirst()]=-1;
                else damier[cp.getFirst()]=damier[cp.getLast()];
                damier[cp.getLast()]=0;
             }
         } 
         // suppression du coup dans la liste
         partie.pop_back();  
    }
 
    // avancée d'un coup
    void Plateau::move(const Coup& cp) { 
         if (damier[cp.getFirst()]>0) {
             // suppression des pions capturés
             for (int i=cp.getPrises().size()-1; i>=0; i--) { 
                 damier[cp.getPrises()[i].pion]=0;
                 val-=cp.getPrises()[i].type; // coup blanc de prise: l'equilibre du jeu bascule en leur faveur
		 			      // ATTENTION: -1 et -2<0, il faut enlever cette valeur negative ;-)
             }
 
             if (cp.getFirst()!=cp.getLast()) { 
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getLast()<45) damier[cp.getLast()]=damier[cp.getFirst()];
                else damier[cp.getLast()]=VD; // promotion en dame
                damier[cp.getFirst()]=0; 
             }
         }
         else { 
             // suppression des pions capturés
             for (int i=cp.getPrises().size()-1; i>=0; i--) {
                 damier[cp.getPrises()[i].pion]=0;
                 val-=cp.getPrises()[i].type; // // coup noir de prise: l'equilibre du jeu bascule en leur faveur
             }
 
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getLast()>=5) damier[cp.getLast()]=damier[cp.getFirst()];
                else damier[cp.getLast()]=-VD; // promotion en dame
                damier[cp.getFirst()]=0;
             }
         } 
         // ajout du coup dans la liste
         partie.push_back(cp);  
    }
 
    // recul d'un coup
    void Plateau::undo() { 
         if (partie.empty()) return; // il faut qu'il y ait au moins un coup à annuler!
         Coup cp=partie.back(); 
         if (damier[cp.getLast()]>0) {
             // restitution des pions capturés
             for (int i=cp.getPrises().size()-1; i>=0; i--) {
                 damier[cp.getPrises()[i].pion]=cp.getPrises()[i].type;
                 val+=cp.getPrises()[i].type;
             }
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getDame()) damier[cp.getFirst()]=1;
                else damier[cp.getFirst()]=damier[cp.getLast()];
                damier[cp.getLast()]=0;
             }
         }
         else {
             // restitution des pions capturés
             for (int i=cp.getPrises().size()-1; i>=0; i--) {
                 damier[cp.getPrises()[i].pion]=cp.getPrises()[i].type;
                 val+=cp.getPrises()[i].type;
             }
             if (cp.getFirst()!=cp.getLast()) {
                // si on a pris des pions adverses avant de revenir sur notre case de départ, il n'y a rien à faire
                if (cp.getDame()) damier[cp.getFirst()]=-1;
                else damier[cp.getFirst()]=damier[cp.getLast()];
                damier[cp.getLast()]=0;
             }
         } 
         // suppression du coup dans la liste
         partie.pop_back();  
    }  
 
    // ajoute les pions pris dans le cas d'une entrée de coup
    Coup Plateau::decoreCoup(Coup cp) {
    	if (abs(cp.getCases()[1]-cp.getCases()[0])<9) return cp;
    	Coup tmp=Coup(cp);
	for (int i=cp.getCases().size()-1; i>0; i--) {
		short dep=cp.getCases()[i-1], arr=cp.getCases()[i];
		// on ajoute les pions pris (une case avant cp.getCases()[i]) ainsi que leur type 
		if (arr-dep>0) 
			// la prise s'est effectuee vers le nord
			if (arr%5>dep%5) 
				// on a pris au NE
				if (arr/5&1) 
					// on est sur une rangee paire en numerotation humaine
					tmp.addPrise(arr-5,damier[arr-5]);
				else 
					// rangee impaire
					tmp.addPrise(arr-6,damier[arr-6]);
			else 
				// on a pris au NO
				if (arr/5&1) 
					// on est sur une rangee paire en numerotation humaine
					tmp.addPrise(arr-4,damier[arr-4]);
				else 
					// rangee impaire
					tmp.addPrise(arr-5,damier[arr-5]);
		else 
			// la prise s'est effectuee vers le sud
			if (arr%5<dep%5) 
				// on a pris au SO
				if (arr/5&1) 
					// on est sur une rangee paire en numerotation humaine
					tmp.addPrise(arr+6,damier[arr+6]);
				else 
					// rangee impaire
					tmp.addPrise(arr+5,damier[arr+5]);
			else 
				// on a pris au SE
				if (arr/5&1) 
					// on est sur une rangee paire en numerotation humaine
					tmp.addPrise(arr+5,damier[arr+5]);
				else 
					// rangee impaire
					tmp.addPrise(arr+4,damier[arr+4]);
	}
	return tmp;
    }
 
    // indique si une position est dynamique (ie: pions en prise) ou statique
    bool Plateau::isStatic(int nbCoups) {
    	// idee: se baser heuristiquement sur le nombre de coups retournes par IterateurCoup, ce qui evite un lourd calcul et 
    	// marchera pendant la 1ere phase de la partie
	if (nbCoups>5) return true; // si nbCoups<=5, alors pas statique, sinon c'est statique, par exemple
	else if (partie.size()<=25) return false;
	return true;    	
    }
 
   // évaluation statique d'une position
   int Plateau::evalPos() { 
       return val; //  A COMPLETER
   }
 
    // stockage de la partie dans un fichier
    void Plateau::stockePartie(char* name) {
    	// preparation du fichier ou on stocke la partie
	std::ofstream file(name); 
	if (!file) {
		std::cout << "erreur lors de l'ouverture du fichier " << name << std::endl;
        	return;
	}
	file.clear();
 
	// on ecrit les coups dans le fichier
	for (int i=0; i<(int)partie.size(); i++) 
		file << partie[i].getString() << " "; 
 
	// fermeture du fichier
	file.close();
    }
 
    // lit des coups dans un fichier en les executant au fur et a mesure
    void Plateau::jouePartie(char* name) {
    	// initialisation d'un plateau
	Plateau plateau=Plateau();
 
    	// ouverture du fichier
	std::ifstream file(name); 
        if (!file) {
            std::cout << "erreur lors de l'ouverture du fichier " << name << std::endl;
            return;
        }
 
	// determination de la taille du fichier:
	// sauvegarder la position courante
        int pos = file.tellg();
    	// se placer en fin de fichier
    	file.seekg(0,std::ios_base::end);
    	// récupérer la nouvelle position = la taille du fichier
    	int size=file.tellg() ;
    	// restaurer la position initiale du fichier
    	file.seekg(pos,std::ios_base::beg) ;
 
        // preparation du buffer de lecture
        char* ch=(char*)malloc(size*sizeof(char));
        file.read(ch,size); // lecture des caractères utiles que l'on place dans ch
 
	// decodage du fichier
	int i=0;
	while (i<size) {
		std::string tmp;
		while (ch[i]!=' ') {
			tmp.push_back(ch[i]);
			i++;
		}    
		plateau.move(decoreCoup(getCoup(tmp)));
		std::cout << plateau << std::endl << std::endl;
		std::cout << "Appuyer sur une entree pour continuer" << std::endl;
    		std::cin.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
		i++;
	}
        file.close();  
    }   
 
    // affichage du tableau
    std::ostream& operator<<(std::ostream& o, const Plateau& p) {  
             for (int i=45; i<50; i++) {
                 o << "| ";
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
             }
             o << "| 10" << std::endl;
             for (int i=40; i<45; i++) {
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
                 o << "| ";
             }
             o << "| 9" << std::endl;
             for (int i=35; i<40; i++) {
                 o << "| ";
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
             }
             o << "| 8" << std::endl;
             for (int i=30; i<35; i++) {
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
                 o << "| ";
             }
             o << "| 7" << std::endl;
             for (int i=25; i<30; i++) {
                 o << "| ";
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
             }
             o << "| 6" << std::endl;
             for (int i=20; i<25; i++) {
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
                 o << "| ";
             }
             o << "| 5" << std::endl;
             for (int i=15; i<20; i++) {
                 o << "| ";
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
             }
             o << "| 4" << std::endl;
             for (int i=10; i<15; i++) {
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
                 o << "| ";
             }
             o << "| 3" << std::endl;
             for (int i=5; i<10; i++) {
                 o << "| ";
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
             }
             o << "| 2" << std::endl;
             for (int i=0; i<5; i++) {
                 if (p[i]==-2) o << "|B";
                 else if (p[i]==-1) o << "|b"; 
                 else if (p[i]==1) o << "|w"; 
                 else if (p[i]==2) o << "|W"; 
                 else o << "|-";
                 o << "| ";
             }
             o << "| 1" << std::endl << " ";
             for (int i=0; i<10; i++) o << (char)(i+'a') << " "; 
             return o;
    }

le code de l'iterateur est trop long, dsl; je poste son header, et TrouveCoup:

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
 
 
#ifndef _IterateurCoup
#define _IterateurCoup
 
/**
 * IterateurCoup: definition du parcours des coups possibles pour un etat
 * donne du plateau de jeu, et recherche du meilleur coup
 */
 
#include "Coup.h"
#include "Plateau.h"
#include <vector>
 
class IterateurCoup {
 
public:
 
  // constructeur vide
  IterateurCoup() {}    
 
  // initialisation par recopie d'un plateau (et avec une couleur de depart)
  IterateurCoup(const Plateau& p, int cl) { 
         plateau=Plateau(p); 
         longueur=0;  
	 color=cl;
  }
 
  // cette méthode réinitialise toutes les variables globales; doit etre appelée avant chaque recherche de coups!
  void reinitialise() {
      longueur=0;
      setCoups.clear();
  }  
 
  // change la couleur courante de jeu
  void changeColor() {
      color=-color;
  }
 
  // inutile en theorie, mais simplifie le deboggage des minMax
  void setColor(int cl) {
  	color=cl;
  }
 
  // IterateurCoup tous les coups possibles dans l'état actuel du plateau, pour une couleur donnée
  std::vector<Coup> findAll();
 
  // IterateurCoup tous les coups possibles pour un pion (ou une dame) donné(e), et les ajoute dans l'ensemble de coups
  void findMoves(Coup cpCour, short pion, short l); // l est la longueur du coup courant
 
  // joue et défait un coup sur le plateau
  void move(Coup cp) { 
      plateau.move(cp);
  } 
  void undo() { 
      plateau.undo();
  } 
 
  // destructeur
  ~IterateurCoup() {}
 
private:
 
  // plateau de la position courante d'analyse
  Plateau plateau;
 
  // longueur maximum d'un coup trouvé jusqu'alors
  int longueur;
 
  // couleur courante (1 si blanc, -1 si noir)
  int color; 
 
  // ensemble des coups trouvés jusqu'alors pour une position donnée
  std::vector<Coup> setCoups; 
 
};
 
#endif

TrouveCoup:

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
 
 
#include "TrouveCoup.h"
#include <vector>
#include <iostream>
 
// a supprimer lorsqu'on ne jouera plus au hasard
#include <cstdlib>
#include <ctime>
 
       // fonction jouant un coup au hasard (seule fonction qui se sert utilement du champ 'color')
 
       Coup TrouveCoup::findLuckyMove() { 
       if (color) iter=IterateurCoup(plateau,1);
       else iter=IterateurCoup(plateau,-1);
       std::vector<Coup> tmp=iter.findAll();
	   int N=tmp.size();
	   if (N==0) {
	       if (color) std::cout << "Les noirs ont gagne!" << std::endl;
               else std::cout << "Les blancs ont gagne!" << std::endl;
               return Coup(-1);
	   }
 
    	   // Set evil seed (initial seed)
       	   srand((unsigned)time(NULL));
	   //int attente=0;   
	   //for (int j=N; j>=0; j--) attente++; // pour laisser un petit temps d'attente (?)
	   return tmp[(int)(N*rand()/(RAND_MAX+1.0))]; ; 
       }       
 
       /* pour l'instant on prend le premier coup de meilleure evaluation;
       amelioration: prendre un coup aleatoirement parmi les meilleurs */
 
       // minMax pour les blancs
       Coup TrouveCoup::minMaxB(int pf) { if (trace) std::cout << "appel minMaxB, prof= " << pf << std::endl;
        if (color) iter=IterateurCoup(plateau,1);
       else iter=IterateurCoup(plateau,-1);
	    int aux,mem; 
	    std::vector<Coup> tmp=iter.findAll(); 
	    // test de fin de partie (peut etre supprime)
	    if (tmp.size()==0) {
	        if (color) std::cout << "Les noirs ont gagne!" << std::endl;
        	else std::cout << "Les blancs ont gagne!" << std::endl;
        	return Coup(-1);
	    } 
	    // souvent aux dames on n'a qu'un ou deux coups valides, correspondant aux prises
	    // d'ou le raccourci suivant; inutile d'explorer des arbres a un seul fils!
	    if (tmp.size()==1) return tmp[0];
	    // on maximise l'evaluation
	    int eval=-20*VD; 
	    for (int i=tmp.size()-1; i>=0; i--) {
	        move(tmp[i]);
		aux=evalRecN(pf-1); if (trace) std::cout << "evaluation retenue pour " << tmp[i] << ": " << aux << std::endl;
		if (aux>eval) {
		    eval=aux;
       		    mem=i;
                } 
                undo(); 
            }
	    return tmp[mem];
       }
 
	// minMax pour les noirs
	Coup TrouveCoup::minMaxN(int pf) { if (trace) std::cout << "appel minMaxN, prof= " << pf << std::endl;
        if (color) iter=IterateurCoup(plateau,1);
       else iter=IterateurCoup(plateau,-1);
	    int aux,mem; 
	    std::vector<Coup> tmp=iter.findAll(); 
	    // test de fin de partie (peut etre supprime)
	    if (tmp.size()==0) {
	        if (color) std::cout << "Les noirs ont gagne!" << std::endl;
        	else std::cout << "Les blancs ont gagne!" << std::endl;
        	return Coup(-1);
	    } 
	    // souvent aux dames on n'a qu'un ou deux coups valides, correspondant aux prises
	    // d'ou le raccourci suivant; inutile d'explorer des arbres a un seul fils!
	    if (tmp.size()==1) return tmp[0];
	    // on minimise l'evaluation
	    int eval=20*VD; 
	    for (int i=tmp.size()-1; i>=0; i--) {
	        move(tmp[i]);
		aux=evalRecB(pf-1); if (trace) std::cout << "evaluation retenue pour " << tmp[i] << ": " << aux << std::endl;
		if (aux<eval) {
		    eval=aux;
       		    mem=i;
                } 
                undo(); 
            }
	    return tmp[mem];
        }
 
 
       // fonction principale de recherche d'un coup: retourne un entier indiquant l'évaluation de la position à la profondeur voulue
       int TrouveCoup::evalRecB(int pf) { if (trace) std::cout << "appel evalRecB, prof= " << pf << std::endl;
 
	    if (trace) std::cout << "plateau courant: " << plateau << std::endl;
	    if (pf==0)  {if (trace) std::cout << "evaluation BB a pf==0: " << plateau.evalPos() << std::endl;return plateau.evalPos();}
            else {
                int aux;   
            if (color) iter=IterateurCoup(plateau,1);
            else iter=IterateurCoup(plateau,-1);
	        std::vector<Coup> tmp=iter.findAll();
	        int eval=-20*VD;
	        for (int i=tmp.size()-1; i>=0; i--) {
	            move(tmp[i]);
		    aux=evalRecN(pf-1);
		    if (aux>eval) eval=aux;
		    undo();
	    	} if (trace) std::cout << "resultat: " << eval << std::endl;
		return eval;
	    }
	}
 
	// fonction principale de recherche d'un coup: retourne un entier indiquant l'évaluation de la position à la profondeur voulue
       int TrouveCoup::evalRecN(int pf) { if (trace) std::cout << "appel evalRecN, prof= " << pf << std::endl;
 
	    if (trace) std::cout << "plateau courant: " << plateau << std::endl;
 
	    if (pf==0) {if (trace) std::cout << "evaluation NN a pf==0: " << plateau.evalPos() << std::endl;return plateau.evalPos();}
	    else { 
	        int aux;   
                 iter=IterateurCoup(plateau,-1);
	        std::vector<Coup> tmp=iter.findAll();
	        int eval=20*VD;   
	        for (int i=tmp.size()-1; i>=0; i--) {
	            move(tmp[i]);
		    aux=evalRecB(pf-1);
		    if (aux<eval) eval=aux;
		    undo();
	    	} if (trace) std::cout << "resultat: " << eval << std::endl;
		return eval;
	    }
	}
 
#ifndef _TrouveCoup
#define _TrouveCoup
 
#include "Coup.h"
#include "Plateau.h"
#include "IterateurCoup.h"
 
/* recherche d'un bon coup */
 
class TrouveCoup {
 
public:
 
       // constructeurs
       TrouveCoup() {}
 
       // Comme dans l'iterateur de coups, on part d'un plateau donne
       TrouveCoup(const Plateau& p, int pf, bool cl) { trace=false;
       	    //compteur=limite; // peut-etre stupide!
	    color=cl; 
	    prof=pf;
	    plateau=Plateau(p);
	    if (cl) iter=IterateurCoup(p,1);
	    else iter=IterateurCoup(p,-1);
       }
 
       // joue un coup sur l'iterateur et sur le plateau
       void move(const Coup& cp) {
           plateau.move(cp);  
       }
 
       // defait le coup precedent sur l'iterateur et sur le plateau
       void undo() {
           plateau.undo();
       }
 
       // change la couleur courante
       void changeColor() { 
           color=!color;
       } 
 
       // fonction jouant un coup au hasard
       Coup findLuckyMove();
 
       // minMax pour les blancs
       Coup minMaxB(int pf); 
 
       // minMax pour les noirs
       Coup minMaxN(int pf);
 
       // evalue recursivement une position pour les blancs
       int evalRecB(int pf);
 
       // evalue recursivement une position pour les noirs
       int evalRecN(int pf);
 
       // destructeur
       ~TrouveCoup() {}
 
private:
 
       // module pour gérer les coups possibles (un nouvel objet est créé à partir de chaque nouvelle position obtenue ?!)
       // mieux: à chaque tour, appeler à la fois plateau.move et trouve.move (peu couteux),
       // et conserver le meme objet Trouve
       IterateurCoup iter;
 
       // plateau de la position courante d'analyse
       Plateau plateau;   
 
       // idee: au lieu de limiter la profondeur, on peut decrementer un entier a chaque appel de cherche
       // on s'arrete lorsqu'on atteint 0 (modulo qqes details..)  
       //int compteur; 
 
       // couleur courante de jeu: true si blanc, false si noir
       bool color;
bool trace;       
       // pour plus d'efficacite, on place la variable "prof" ici; elle ne change pas pour un objet donne!! 
       // ceci dit, on pourra moduler la profondeur de recherche en fonction du stade de la partie
       int prof;
 
};
 
#endif

12/03/2006, 00h29
Laurent Gomila

Tu ne peux pas essayer d'isoler le problème (avec un debugger par exemple) histoire de virer le code inutile dans tout ça ? ...