list objet modification des données imprévue

**mathher** · 13/04/2006, 11h27

bonjour,

mon probleme est le suivant :
je dispose d'un objet Piece qui contient un variable nom qui est un char et une variable forme qui est un tableau de positions (peut importe)

lorsque j'accède au nom de la piece il me renvoie bien le char
mais lorsque je place la piece dans une structure de données comme une liste, il change le nom de la piece en | ou rien du tout.

je ne comprends vraiment pas pourquoi il fait ca

quelqu'un saurait-il m'aider?

s'il le faut je préciserai le probleme

merci

**r0d** · 13/04/2006, 11h46

J'ai l'impression qu'il s'agit d'un problème de constructeur de recopie. Pourrais-tu donner plus de précisions stp (ton code par exemple) ?

**mathher** · 13/04/2006, 11h50

j'ai appris la programmation en java alors le constructeur de copie je comprends pas vraiment ce que c'est et a quoi ca sert d'ailleurs je n'en ai pas fait voila quand meme le code

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
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
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
#ifndef ListPieces_h
#define ListPieces_h
using namespace std;
 
typedef struct PNode{
        Piece *elem;
        struct PNode *next;
        struct PNode *prev;
 
}PieceNode;
 
class ListPieces{
 
private:
 
int numelts;
PieceNode *header;
PieceNode *tailer;
 
 
public:
 
//CONSTRUCTEUR
ListPieces();
ListPieces(Piece *elem) ;
 
//DESTRUCTEUR
~ListPieces() ;
 
///////////////////////////////////////////////////////////////
//METHODES D'INFORMATION
 
/*
@pre : -
@post : renvoie la taille de la liste
*/
int const size() ;
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie un booleen true si la liste est vide false sinon
*/
bool const isEmpty() ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
 
//METHODES D'ACCES
/*
@pre : -
@post : renvoie l'élément stocké dans le noeud node
*/
Piece* getElement(PieceNode *node);
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le premier noeud de la liste
*/
PieceNode* first() ;
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le dernier noeud de la liste
*/
PieceNode* last() ;
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud suivant celui donné
*/
PieceNode* next(PieceNode *node) ;
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud précédant celui donné
*/
PieceNode* prev(PieceNode *node) ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
//METHODES DE MISE A JOUR
 
 
/*
@pre : -
@post : insère et renvoie un noeud en début de liste
*/
PieceNode* insertFirst(Piece *elem) ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud en fin de liste
*/
PieceNode* insertLast(Piece *elem) ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud après le noeud donné
*/
PieceNode* insertAfter(Piece *elem, PieceNode *pos) ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud avant le noeud donné
*/
PieceNode* insertBefore(Piece *elem, PieceNode *pos) ;
 
///////////////////////////////////////////////////////////////
};
 
#endif
 
 
 
#include "ListPieces.h"
using namespace std;
 
ListPieces::ListPieces(){
         numelts = 0;
         header = new PieceNode;
         tailer = new PieceNode;
         header->next = tailer;
         header->prev = NULL;
         tailer->prev = header;
         tailer->next = NULL;
}
ListPieces::ListPieces(Piece *elem){
         numelts = 1;
         header = new PieceNode;
         tailer = new PieceNode;
         PieceNode *newnode = new PieceNode;
         newnode->elem = elem;
         header->next = newnode;
         tailer->prev = newnode;
         newnode->next = tailer;
         newnode->prev = header;
         header->prev = NULL;
         tailer->next = NULL;
}
 
ListPieces::~ListPieces(){
          delete &numelts;
          delete header;
          delete tailer;
}
 
///////////////////////////////////////////////////////////////
//METHODES D'INFORMATION
 
/*
@pre : -
@post : renvoie la taille de la liste
*/
int const ListPieces::size() {
     return numelts;
}
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie un booleen true si la liste est vide false sinon
*/
bool const ListPieces::isEmpty() {
     if(numelts==0)
          return true;
     else
          return false;
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie un booleen true si la liste est vide false sinon
*/
Piece* ListPieces::getElement(PieceNode *node){
       return node->elem;
 
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
 
//METHODES D'ACCES
 
/*
@pre : -
@post : renvoie le premier noeud de la liste
*/
PieceNode* ListPieces::first() {
            return header->next;
}
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le dernier noeud de la liste
*/
PieceNode* ListPieces::last() {
            return tailer->prev;
}
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud suivant celui donné
*/
PieceNode* ListPieces::next(PieceNode *node) {
            return node->next;
}
 
 
 
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : renvoie le noeud précédant celui donné
*/
PieceNode* ListPieces::prev(PieceNode *node) {
            return node->prev;
}
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
//METHODES DE MISE A JOUR
 
 
/*
@pre : -
@post : insère et renvoie un noeud en début de liste
*/
PieceNode* ListPieces::insertFirst(Piece *elem) {
            numelts=numelts+1;
            PieceNode *newnode = new PieceNode;
            newnode->elem=elem;
            newnode->next=header->next;
            newnode->prev=header;
            header->next->prev=newnode;
            header->next=newnode;
            return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud en fin de liste
*/
PieceNode* ListPieces::insertLast(Piece *elem) {
            numelts=numelts+1;
            PieceNode *newnode = new PieceNode;
            newnode->elem=elem;
            newnode->next=tailer;
            newnode->prev=tailer->prev;
            tailer->prev->next=newnode;
            tailer->prev=newnode;
            return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud après le noeud donné
*/
PieceNode* ListPieces::insertAfter(Piece *elem, PieceNode *pos) {
           numelts=numelts+1;
           PieceNode *newnode = new PieceNode;
           newnode->elem=elem;
           newnode->next=pos->next;
           newnode->prev=pos;
           pos->next=newnode;
           newnode->next->prev=newnode;
           return newnode;
}
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
/*
@pre : -
@post : insère et renvoie un noeud avant le noeud donné
*/
PieceNode* ListPieces::insertBefore(Piece *elem, PieceNode *pos) {
           numelts=numelts+1;
           PieceNode *newnode = new PieceNode;
           newnode->elem=elem;
           newnode->next=pos;
           newnode->prev=pos->prev;
           pos->prev=newnode;
           newnode->prev->next=newnode;
           return newnode;
}
 
 
///////////////////////////////////////////////////////////////
 
 
 
#ifndef Piece_h
#define Piece_h 
 
class Piece{
 
public:
//CONSTRUCTEUR PAR DEFAUT
Piece() ;
 
//CONSTRUCTEUR
/*
@pre : form pointe vers un tableau de positions décrivant la
       forme d'une pièce, name est un nom de piece, size est le 
       nombre de blocs formant la pièce
@post : un objet Piece est créé, et contient la forme d'une 	
	    pièce grâce à un tableau de position, son nom et sa taille  
*/
Piece(Position *form, char name, int size) ;
 
//DESTRUCTEUR
~Piece() ;
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
//METHODES D'ACCES
 
/*
@pre : -
@post : renvoie le pointeur vers le tableau de positions 
        correspondant à la forme de la pièce courante
*/
Position* const getForme() const ;
 
///////////////////////////////////////////////////////////////
/*
@pre : le nom de la piece courante a été fixé
@post : renvoie le nom de la pièce courante
*/
char const getNom() const ;
 
///////////////////////////////////////////////////////////////
/*
@pre : la taille de la piece courante a été fixée
@post : renvoie la taille de la pièce courante
*/
int const getTaille() const ;
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
// METHODES :
 
/*
@pre : La pièce courante a une forme définie
       posvides reprend les positions vide d'une configuration
       poscourante est la position courante de la pièce 
       (supérieure gauche)
       
@post : renvoie un pointeur vers une  matrice contenant toutes les nouvelles 
        positions de la pièce si un ou plusieurs déplacements 
        de la pièce sont possibles 
        - la première ligne comprend les nouvelles positions si un déplacement 
          vers le bas est possible
        - deuxième ligne -> vers la gauche
        - toisième ligne -> vers le haut
        - quatrième ligne -> vers la droite
        si le déplacement correspondant n'est pas possible, le premier élément 
        de la ligne est la position (0,0)            
*/
 
Position** ableToMove(Position *posvides, int nbre_pos_vides, Position *poscourante) ;
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
private:
 
//VARIABLE(S) D'INSTANCE
 
Position *forme ;
char *nom ;
int *taille ;
 
};
 
#endif
 
 
 
#include "Piece.h"
 
 
//CONSTRUCTEUR PAR DEFAUT
Piece::Piece(){
     forme = 0; 
     nom = new char ;
     taille = new int ;
}
 
//CONSTRUCTEUR
Piece::Piece(Position *form, char name, int size){
     forme = form ;
     nom = &name;
     taille = new int ; *taille = size ;
 
}
 
//DESTRUCTEUR
Piece::~Piece(){
     delete forme ; 
     delete nom ; 
     delete taille ;              
}
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
//METHODES D'ACCES
 
char const Piece::getNom() const {
     return *nom;
}
 
///////////////////////////////////////////////////////////////
 
int const Piece::getTaille() const {
     return *taille;
}
 
///////////////////////////////////////////////////////////////
Position* const Piece::getForme() const{
    return forme ;
}
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
 
// METHODES :
 
Position** Piece::ableToMove(Position *posvides, int nbre_pos_vides, Position *poscourante){
 
     int largeur = *taille ; // taille est une variable d'instance
 
     int hauteur = 4 ;
 
     // création du tableau de résultats
     Position** res = new Position*[hauteur] ;
 
     for(int z=0 ; z<hauteur ; z++){
             Position* tab = new Position[largeur] ; 
             res[z] = tab ;
             Position* rien = new Position(0,0) ;
             res[z][0] = *rien ; // valeur 0 au début de chaque ligne
             }
 
     // coordonnées courantes
     int xo = (*poscourante).getX() ;
     int yo = (*poscourante).getY() ;
 
     // coordonnées de forme du 1er bloc
     int xa = (forme[0]).getX() ;
     int ya = (forme[0]).getY() ;
 
     //////////////////////////////  
     // variables pour les boucles
     //////////////////////////////
     Position cur ; // position courante dans le check
     int xcur ; int ycur ; // coord de la position courante
     int tot = largeur+nbre_pos_vides ; // nombre de positions à checker
     int cpt ;
     int xp, yp, j, k ; 
     //////////////////////////////
 
     for(int i = 1 ; i <= 4 ; i++){
             switch(i){
             case 1: xp = 1; yp = 0 ; break ;
             case 2: xp = 0; yp = -1 ; break ;
             case 3: xp = -1; yp = 0 ; break ; 
             case 4: xp = 0; yp = 1 ; break ;
             }
 
             j = 0 ;
             cpt = 0 ;
 
             // parcours de tous les blocs de la pièce
             while(j < largeur){ 
                  cur = forme[j] ;
                  xcur = (cur).getX() + xo + xp - xa ;
                  ycur = (cur).getY() + yo + yp - ya ;
                  k = 0 ; 
 
                  while(k<tot){
 
                       // check des positions vides 
                       if(k>=largeur){                                                  
                           if(posvides[k-largeur].getX() == xcur && posvides[k-largeur].getY() == ycur){
                                   // sortie du while avec succès pour le bloc              
                                   j++; k =tot + 1 ; cpt++ ;      
                                   }   
                           else k++ ; // essai avec le bloc suivant 
                           }
 
                       // check des positions laissées vide par le déplacement de la pièce                  
                       if(k<largeur){
                           if((forme[k].getX()+xo-xa) == xcur && (forme[k].getY()+yo-ya) == ycur){
                                   // sortie du while avec succès pour le bloc           
                                   j++; k =tot+1 ; cpt++;
                                   }          
                           else k++ ; // essai avec le bloc suivant         
                           }
 
                       // échec du déplacement régi par i    
                       if(k==tot) j = largeur ;  
                  }
 
                  if(cpt == largeur){ // déplacement du bloc possible
                                      // stockage de la possibilité de déplac
 
                         for(int l=0;l<largeur;l++){
                               Position* posok = new Position(forme[l].getX()+xo + xp - xa, forme[l].getY()+yo + yp - ya) ; 
                               res[i-1][l] = *posok ;                 
 
                              }
 
                  }
             }
 
         }
 
         return res;
 
 
 
 
 
     }
 
 
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////

**r0d** · 13/04/2006, 12h11

Pourquoi as-tu implémenté la liste chainée??! Utilise plutôt l'objet vector de la stl, et:
1/ Tu n'aura plus qu'une ou deux ligne de code par méthode
2/ Ta liste est optimisée, garantie sans bug, et il sera très simple de rajouter des fonctionnalités à l'objet qui la contient.

**Matthieu Brucher** · 13/04/2006, 12h47

Et c'est sûr, tu devrais utiliser la STL pour ça.

**mathher** · 13/04/2006, 12h48

c'etait justement un probleme que j'avais posé précédemment comment rajouter simplement des méthodes à vector pour l'appliquer sur les objets dont je dispose

sinon le constructeur de copie devrait ressembler à quoi?

**mathher** · 13/04/2006, 12h58

apres avoir fait d'autres tests il s'avere que l'information est moifiee lorsque je copie la piece
ce qui semble bizarre c'est qu'il n'y a que le nom de la piece qui change mais pas la forme ni la taille

**r0d** · 13/04/2006, 12h59

Attend un peu... je m'excuse mais ton code ressemble plus à du C (int*, char*

) qu'à du C++, et je ne parviens pas à comprendre où est ton problème. Pourrais-tu me dire exactement la ligne qui pose problème?

Si cependant, tu préfère appliquer nos conseils et utiliser des vector, tout est expliqué dans la faq. D'ailleurs, à la place d'un int* tu devrais utiliser un std::vector<int>, et au lieu d'un char* (argh...) un std::string
Idem, tout cela est expliqué dans la faq.

**mathher** · 13/04/2006, 13h05

le probleme se situe dans un fichier annexe

qui serait de la forme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include "tous les fichiers avant"
 
main(){
 
     Piece *P = new Piece(f1,'A',2);
 
 
     Piece *Q = P;  
     cout << Q->getNom() << endl;  // ici il affiche | au lieu de A;
 
}

**r0d** · 13/04/2006, 13h09

sinon, sur le code que tu m'a fourni, à savoir:

Code :

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

1
2
3
4
5
6
7
8
#include "tous les fichiers avant"
 
main()
{
    Piece *P = new Piece(f1,'A',2);
    Piece *Q = P;
    cout << Q->getNom() << endl; // ici il affiche | au lieu de A;
}

Si tu affiche P->getNom(), que t'affiche-t-il?

**mathher** · 13/04/2006, 13h10

si je le fais avant de déclarer Q il affiche A et apres il affiche |

**mathher** · 13/04/2006, 13h26

et si je fais

Code :

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

1
2
3
4
5
6
 
 
Piece *Q = new Piece();
*Q = *P ;
 
cout << Q->getNom() << endl;

il affiche un caractère vide (un blanc quoi)

**r0d** · 13/04/2006, 13h36

essaie ça pour voir:

Code :

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

1
2
3
4
Piece *P = new Piece(f1,'A',2);
Piece *Q = new Piece();
P=Q;
cout << Q->getNom() << endl;

**mathher** · 13/04/2006, 16h30

j'ai trouve comment resoudre le probleme

au lieu de declarer char*nom comme un pointeur
il faut declarer char nom comme une variable

je sais pas pourquoi mais ca marche

**Matthieu Brucher** · 13/04/2006, 17h16

Ils devaient pointer tous les 2 vers la même chaîne, au hasard ? C'est le principe du constructeur implicite par recopie, il remplit les champs d'une classe en copiant ce que l'autre a, sans faire d'allocations.

list objet modification des données imprévue

C++

Vue hybride

Discussions similaires

Partager

Partager