Discussion :

[razily]

Bonjour à tous ;
je ne comprends pas comment devrait-on faire pour déclarer une variable qui sera utilisée par un certain nombre de classe .
en fait pour simplifier au départ j'ai mis tout sur un même fichier .cpp

j'ai une variable : Piece* SS[8][8] ; et que j'aimerai bien que tout les classes travaillent sur cette variable

j'ai essayé de la déclarer comme variable globale .
pour simplifier voici la structure du fichier .cpp

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
 
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std ;
 
 // voici la variable en question 
// je voudrai créer un plateau composée de pointeur sur des pièces 
Piece* SS[8][8] ;  
 
class Coordonnee {
 
ici attributs et méthode Coordonee
};
 
class Piece {
 
ici attributs et méthode Piece
 
}
 
class Pion :public Piece {
ici attributs et méthode Pion
}
 
class Plateau{
 
		public :
 
	  Plateau();
	void 	Affichage();
 
 
			};
 
 
 
 
		Plateau::Plateau(){
 
			for(int i = 0 ; i<8;i++){
				for(int j=0;j<8;j++){
					SS[i][j]=0;
						}}
			Piece *P1= new Piece(2,2,1,'P');
			Piece *P2=new Piece(3,3,2,'P');
			Piece *P3=new Piece(4,4,1,'P');
			Piece *P4=new Piece(5,6,2,'P');
			Piece *P5=new Piece(6,7,1,'P');
 
			   SS[2][2] = P1;
				SS[3][3] = P2;
				SS[4][4] = P3;
				SS[5][6] = P4;
				SS[6][7] = P5;
 
 
			}
 
 
void Plateau::Affichage(){
 
			int val = 0;
			int ligne , colonne ;
			int ligne1 , colonne1; 
			Piece* Ptr = NULL;
 
 
			while(val!=1) {
 
			for(int i = 0 ; i<8;i++){
				for(int j=0;j<8;j++){
					if(SS[i][j]==0){
						cout << "_" <<" " ;
						}
					else{
                          cout << SS[i][j]->getEtiquette() << " " ;
						}
 
 
					}
 
				cout << endl ;
 
 
				}
 
			cout << "entrer le point actuel :\n";
	        cin >> ligne >> colonne;
 
	         cout << "ligne:" << ligne <<"colonne:" << colonne << endl ;
 
			 cout << "entrer le d'arrivee :\n";
	        cin >> ligne1 >> colonne1;
 
	         cout << "ligne:" << ligne1 <<"colonne:" << colonne1 << endl ;
 
 
			 Ptr = SS[ligne1][colonne1];
 
 
bool resultat = SS[ligne][colonne]->ValiderDeplacement(ligne1,colonne1,Ptr);
 
if(resultat==1){
	        SS[ligne][colonne]->Deplacer(ligne1,colonne1);
			SS[ligne1][colonne1] = SS[ligne][colonne];
			SS[ligne][colonne] = 0;
 
		}
	else{
	cout << "impossible de se déplacer" << endl ;
 
		}
}

mon problème c'est que là , je rassemble tout sur un même fichier , mais lorsque je sépare chaque classe dans chaque fichier .cpp
comment et où est ce que je déclare
Piece* SS[8][8] ;
pour qu'elle soit accessible pour toutes les classes ??

avant je suis dèjà à tenter dans un fichier à part Commun.h à faire comme ceci , et inclure Commun.h pour chaque classe susceptible d'utiliser la variable SS mais il y a une erreur de multi définition

#ifndef _COMMUN_H
#define _COMMUN_H

Piece* SS[8][8] ;

#endif

autre question , vous croyez dans ce genre de chose , qu'il est préferable de mettre SS en static car je ne vois pas trop la nécessité et le rôle de static pour une variable ou une fonction

merci d'avance

[jabbounet]

concernant le static.
http://cpp.developpez.com/faq/cpp/?page=static


Par contre, je ne suis personnellement pas fan des variables globales, c'est souvent source de bug car on ne maîtrise pas les modifications qui leurs sont appliquées. Sans compter les soucis que cela peux poser si tu faire passer ton application en multi-thread.

[koala01]

Salut,

Une fonction statique n'a réellement de sens que pour les fonctions membres de classes, car elle permet de rendre la fonction indépendante de toute instance de la dite classe.

C'est la raison pour laquelle tu dois transmettre une instance de la classe, si ta fonction statique doit manipuler une instance donnée.

De son coté, une variable statique n'a réellement de sens que dans une fonction (ce qui permet à la variable de garder la même valeur de la fin d'un appel de la fonction au début de l'appel suivant) ou dans une classe, car elle est alors également indépendante de toute instance de la classe.

Une variable globale produira en effet exactement le même résultat, sans pour autant être déclarée statique

La solution à ton problème ne passera donc pas par le fait de déclarer ta variable comme étant statique, mais plutôt par le fait de la déclarer extern.

Ce mot clé permet de dire au compilateur qu'il existe bien une variable du nom indiqué "quelque part" dans le code objet, et qu'il n'est donc pas nécessaire de prévoir une adresse pour celle-ci chaque fois qu'il en rencontre la déclaration (bon, c'est simplifié, mais l'idée y est )

Tu peux donc déclarer ta variable globale dans un fichier d'en-tête proche de
fichier MyVar.h

Code :

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

1
2
3
4
#ifndef MYVAR_H_INCLUDED
#define MYVAR_H_INCLUDED
extern Piece* SS[8][8] ;
#endif // MYVAR_H_INCLUDED

et avoir une déclaration "réelle" de la variable dans un fichier d'implémentation proche de
fichier MyVar.cpp

Code :

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

1
2
3
/* il peut y avoir des includes éventuels */
Piece* ss[8][8]; // seule cette déclaration provoque la création d'une
                 // variable globale

De cette manière, tu pourra inclure le fichier d'en-tête (ici MyVar.h) dans tout fichier qui nécessite de pouvoir accéder à la variable globale, le plus souvent dans... un fichier d'implémentation ( *.cpp) car l'utilisation ne se fera que... dans une implémentation de fonction

Par exemple: MyClass.h

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef MYCLASS_H_INCLUDED
#define MYCLASS_H_INCLUDED
/* on n'a, a priori, aucune raison d'avoir acces à ss ici */
class MyClass
{
    public:
        /*...*/
        void foo(); /* uniquement la déclaration ici :D */
};
#endif // MYCLASS_H_INCLUDED

MyClass.cpp

Code :

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

1
2
3
4
5
6
7
8
9
#include <MyClass.h> // il faut bien la définition de la classe :D
#include <MyVar.h> // pour pouvoir accéder à la variable globale
/* cette fonction aura pour résultat de créer les 64 pieces possibles */
void MyClass::foo()
{
    for(int i=0;i<8;++i)
        for(int j=0;j<8;++j)
            ss[i][j]= new Piece(/* parametres éventuels*/);
}

Ceci dit, il faut se rappeler que "les variables globales CEYMAL"...

Il faut les éviter autant que possibles

Il est, de plus, très rare que toutes les classes (ou même seulement qu'une grande partie des classes) doivent accéder à une variable particulière...

[razily]

Salut,


Ceci dit, il faut se rappeler que "les variables globales CEYMAL"...

Il faut les éviter autant que possibles

Il est, de plus, très rare que toutes les classes (ou même seulement qu'une grande partie des classes) doivent accéder à une variable particulière...

Bonjour ,

en tout cas Merci pour vos réponses ;
mais à part déclarer cette variable globale , existe t-il un autre manière de faire pour que certaine classe comme Pion Reine etc ... la reconnaisse
parce que en fait pour chaque classe(Pion-Roi etc ..) j'ai une méthode validerDeplacement comme ceci qui fait appel à la variable SS :

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
 
bool Roi::ValiderDeplacement(int x,int y,Piece* Ptr){
				Coordonne temp;
				Coordonne* temp2,*temp3,*temp5;
				int val ;
				bool valide = false ;
				bool trouve = false ;
				Emplacement casesValidesRoi;
				Emplacement deplacement;
				vector<Coordonne*>::iterator i;
				vector<Coordonne*>::iterator ii;
				int ligne , colonne ;
				Coordonne* VecteurRoi1 = new Coordonne(-1,-1);
				Coordonne* VecteurRoi2 = new Coordonne(-1,0);
				Coordonne* VecteurRoi3 = new Coordonne(-1,1);
				Coordonne* VecteurRoi4 = new Coordonne(0,-1);
				Coordonne* VecteurRoi5 = new Coordonne(0,1);
				Coordonne* VecteurRoi6 = new Coordonne(1,-1);
				Coordonne* VecteurRoi7 = new Coordonne(1,0);
				Coordonne* VecteurRoi8 = new Coordonne(1,1);
 
				// on insere dans un vector
 
				casesValidesRoi.push_back(VecteurRoi1);
				casesValidesRoi.push_back(VecteurRoi2);
				casesValidesRoi.push_back(VecteurRoi3);
				casesValidesRoi.push_back(VecteurRoi4);
				casesValidesRoi.push_back(VecteurRoi5);
				casesValidesRoi.push_back(VecteurRoi6);
				casesValidesRoi.push_back(VecteurRoi7);
				casesValidesRoi.push_back(VecteurRoi8);
 
				for(i = casesValidesRoi.begin();i!=casesValidesRoi.end();i++){
						cout << *i << " " ;
 
					}
 
				for(i= casesValidesRoi.begin(); i!= casesValidesRoi.end();++i)
					 {
 
					 if(*i==NULL)
						 {
                          cout <<"erreur de creation de vectore roi\n" ;
 
						 }
					 else {
						 // succès et on traite
						 temp = this->Place + *i ;
 
							// on teste si entre 1 et 8
						 if(((temp>=1)==0)&&((temp<=8)==0))
								{
 
							 temp2 = new Coordonne(temp);
							 deplacement.push_back(temp2);
 
								}
 
 
 
							}
 
 
 
 
					 }
 
 
				  for(i=deplacement.begin(); i!= deplacement.end();i++)
					 {
 
                          cout <<"vector dans deplacement" <<*i <<" " ;
 
						 }
 
				  i=deplacement.begin();
 
				  temp3 = new Coordonne(x,y);
				  val = 0;
				  ii = deplacement.begin();
 
		  while((ii!=deplacement.end())&&(trouve==false)){
 
				   temp5 = *ii;
				   if((*temp3==*temp5)==0){
					   trouve = true;
 
					   }
				   else {
					   ii++;
 
					   }
 
				   }
 
			   val = distance(i,ii);
 
			   cout << "la valeur se trouve a la"<<" " << val <<" " <<  "eme position" << endl;
          //     cout << "la valeur de *ii est" << *ii << endl ;
			   if(trouve==true)
 
	    {
 
				   cout << "il faut verifier la presence d'une piece de la case "  << endl ;
                       temp5 = *ii;
				   ligne = temp5->getLigne();
				   colonne = temp5->getColonne();
				     Ptr = SS[ligne][colonne];
 
			  if( Ptr==0){
 
					   cout << " Le roi peut se déplacer case vide " << endl ;
					   valide = true ;
 
					       }   
 
//  "s'il y a il faut s'assurer que il a une couleur differente "  
 
		        else    {
 
					  if(this->getCouleur()!= Ptr->getCouleur())
						    {
 
						   cout << "y a bien une piece adverse" << endl ;
						     valide = true ;
 
						      }
					  else {
						       cout << "vous ne pouvez pas attaquer votre propre piece " << endl ;
							   valide = false ;
 
						    }
       	              }
 
	      }
 
			   else {
                     cout <<"impossible de se deplacer"<< endl ;
				   }					 
 
 
 
 
				return valide ;
				}

peut-être une autre manière de le faire aussi , c'est de mettre la variable SS (en protected )comme attribut de Plateau et de mettre validerDeplacement comme ami

Code :

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

1
2
3
4
5
6
7
8
9
 
class Plateau {
 
friend bool ValiderDeplacement(int x,int y,Piece* Ptr);
protected :
 
Piece* SS[8][8];
 
}

or la méthode bool ValiderDeplacement(int x,int y,Piece* Ptr) est dèjà Virtuel dans la classe Piece

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class Piece {
 
virtual bool ValiderDeplacement(int x,int y,Piece* Ptr);
}
 
class Pion : public Piece {
 
 
 bool ValiderDeplacement(int x,int y,Piece* Ptr);
 
}

[Getrix]

Bonjour,

pour rendre ta variable SS[ ][ ] accessible dans toutes tes classes, il te suffit normalement d'écrire dans UN fichier .cpp le code pour créer ta variable (code classique quoi), et dans tes fichiers de classe (le .h par exemple) tu rajoutes pour chaque classe le code :

Code :

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

extern Piece* SS[8][8];

Ainsi, le compilateur reconnaîtra à chaque fois ta variable, et la mémoire ne sera bien réservée qu'une seule fois (donc pas de multidéfinition).
Attention : variable globale ! Consommer avec beaucoup de modération !!

Voilà tout

[bruno_pages]

Bonjour ,

peut-être une autre manière de le faire aussi , c'est de mettre la variable SS (en protected )comme attribut de Plateau et de mettre validerDeplacement comme ami

Code :

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

1
2
3
4
5
6
7
8
9
 
class Plateau {
 
friend bool ValiderDeplacement(int x,int y,Piece* Ptr);
protected :
 
Piece* SS[8][8];
 
}

cela repousse le problème sans avancer car la chose étant un attribut d'instance et non de classe il faudra trouver un moyen d'accéder à l'instance de plateau.

A moins que le programme ne traite simultanément plusieurs parties le plateau quelque soit sa représentation est typiquement un singleton

s'il n'y a qu'un plateau (une partie) pourquoi la chose n'est-elle par une variable de la classe Piece (attribut static de Piece) ? ainsi toute sous classe de Piece pourra y accéder soit parce que l'attribut est protected, soit via des opérations appropriées définie sur Piece.

[koala01]

A vrai dire, le plateau de jeu est un contenant de pièces, si les différentes pièces doivent effectivement pouvoir accéder au plateau de jeu, ce n'est pas systématique (étant donné qu'elle représentent... le contenu)...

Or, dans la logique, on pourrait estimer que l'on accède au contenu (les pièces) au travers du contenant, et donc, pourquoi ne pas, tout simplement, transmettre le plateau de jeu en argument aux différents comportements des pièces qui en ont besoin

Tu aurais, dans l'ensemble, quelque chose prenant la forme de

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
class Echiquier;
/* la pièce... Malheureuse victime de notre combat */
class Piece
{ 
    public:
        Piece(eCouleur, int posX, int posY); // eCouleur: blanc ou noir ;)
        /* pour savoir si la pièce peut bouger vers une position donnée
         * le comportement dépend en partie du type de la piece
         */
        virtual bool canMove(int pX, int pY, Echiquier *) const; 
        void move(int pX, int pY, Echiquier * e)
        {
            e->caseAt(pX,pY).changePiece(e,this);
            posx_=pX;
            posx_=pY;
        }
        /* récupération des coordonnées de la pièce */
        int posX() const{return posx_;}
        int posY() const{return posy_;}
    private:
        int posx_; // position X de la pièce sur l'échiquier
        int posy_; // position Y de la pièce sur l'échiquier
};
/* Pion, Tour, Cheval, Roi et Reine hérite de Piece :D */

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
 
/* la case, subdivision de notre terrain de jeu */
class Case
{
    public:
        Case(int px, int py):posx_(px),posy_(py),p_(NULL){}
        /* pour récupérer la pièce qui se trouve sur la case en question
         * renvoie NULL s'il n'y en a pas
         */
        Piece* lapiece() const{return p_;}
        /* modifie la pièce qui se trouve sur cette case*/
        void changePiece(Echiquier * e, Piece * p=NULL)
        {
            /* s'il y a une pièce sur la case et qu'une nouvelle piece
             * vient dessus
             */
            if(p)
            {
                e->removeFromGame(p_); // l'ancienne est bouffée
            }
            /* et la nouvelle piece prend sa place */
            p_=p;
        }
        /* récupération des coordonnées de la case */
        int posX() const;
        int posY() const;
        /* permet de savoir s'il y a une pièce sur la case */
        bool isUsed()const{return p_!=NULL;}
    private :
        int posx_;
        int posY_;
        Piece * p_;
};

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
 
/* L'échiquier, là où tout se joue... */
class Echiquier
{
    public:
        Echiquier()
        {
            /* rajouter les 64 cases (vides dans un premier temps) */
            for(int i=0;i<8;++i)
                for(int j=0;j<8;++j)
                    case_.push_back(Case(i,j));
            /*créer les 32 pièces */
            for(int i=0;i<8) /* les 16 pions */
            {
                ingame_.push_back(new Pion(blanc, i,1));
                ingame_.push_back(new Pion(noir,i,6));
             }
             /* les quatre tours */
             ingame_.push_back(new Tour(blanc,0,0));
             ingame_.push_back(new Tour(blanc,7,0));
             ingame_.push_back(new Tour(noir,0,7));
             ingame_.push_back(new Tour(noir,7,7));
             /* les quatre cavaliers */
             ingame_.push_back(new Cheval(blanc, 1,0));
             ingame_.push_back(new Cheval(blanc,7,0));
             ingame_.push_back(new Cheval(noir,1,0));
             ingame_.push_back(new Cheval(noir,1,7));
             /* tu as compris le principe :D */
             /* créer la relation entre les pièces et les cases */
             for(std::vector<Pieces *>::iterator it=ingame_.begin();
                 it!=ingame_.end();++it)
             {
                 case_[(*it)->posX()*8 +(*it)->posy()]=(*it);
             }
        }
        ~Echiquier()
        {
            /* on détruit correctement les pieces restant en jeu */
            for(std::vector<Piece*>::iterator it=ingame_.begin();
                it!=ingame_.end();++it)
                delete (*it);
            /* et les pièces qui ont été mise "hors jeu" */
            for(std::vector<Piece*>::iterator it=removed_.begin();
                it!=removed_.end();++it)
                delete (*it);
        } 
        Case & caseAt(int x, int y){return case_[x*8+y];}
        Case const & caseAt() const{return case_[x*8+y];}
        void removeFromGame(Piece * p)
        {
            /* on transfert la piece p de "ingame_" à "removed_" */
            removed_.push_back(p);
            for(std::vector<Piece*>::iterator it=ingame_.begin();
                it!=ingame_.end(); ++it)
                if((*it)==p)
                    ingame_.erase(it);
        }
        bool estMat(eCouleur) const;
        bool estPat(eCouleur) const;
    private:
        std::vector<Piece*> ingame_; /* les pièces "en jeu" */
        std::vector<Piece*> removed_; /* les pièces "hors jeu" */
        std::vector<Case> case_; /* les cases de l'échiquier */
};

Code :

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

1
2
3
4
5
6
7
8
9
10
 
/* le joueur: celui qui envoie ses pièces vers une mort atroce */
class Joueur
{
    public:
        eCouleur couleur() const;
    /*...*/
 
};
/* on peut envisager de faire dériver JoueurHumain et AI de Joueur */

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
/* La partie */
class Partie()
{
    public:
        void jouer()
        {
            Joueur *actuel=j1;
            while(checkAgain(actuel->couleur())
            {
                 /*...*/
                 actuel=(actuel==j1? j1:j2);
            }
 
        }
    private:
        void checkAgain(eCouleur c)
        {
            return ech_.estMat(c)||ech_.estMat(c);
        }
        Joueur *j1; //humain ou AI, a les blancs
        Joueur *j2; // l'adversaire, a les noirs
        Echiquier ech_;
}

Code :

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

1
2
3
4
5
6
/* La fonction principale */
int main()
{
    Partie p;
    p.jouer();
}

[bruno_pages]

transmettre le plateau de jeu en argument aux différents comportements des pièces qui en ont besoin

j'y avais bien-sur pensé, mais je trouve cela bien lourd, encore une fois le plateau étant unique autant utiliser un singleton (qu'elle qu'en soit l'implémentation)

[koala01]

j'y avais bien-sur pensé, mais je trouve cela bien lourd, encore une fois le plateau étant unique autant utiliser un singleton (qu'elle qu'en soit l'implémentation)

Un singleton ne sera pas forcément utile, et même sans doute très embêtant...

En effet, l'unitcité du plateau doit être assurée... au niveau de la partie, mais rien n'empêche forcément d'avoir... plusieurs parties en cours en même temps.

Et, dans ce cas, il faudra bel et bien... un plateau par partie

C'est pourquoi, le plus simple est sans doute encore d'assurer l'unicité (relative) du plateau en ne déclarant... qu'un seul plateau par partie, quitte, si on n'envisage qu'une seule partie en même temps, à veiller à ce que ce soit réellement le cas au moment où le jeu est lancé.

Le pattern singleton est, certes, très intéressant, mais il arrive régulièrement que les gens y aient recours "à tord et à travers".

Par contre, il serait éventuellement envisageable (car il est vrai que le passage systématique du plateau sous la forme d'un argument peut être assez lourd à gérer) de créer un rappel de la liaison avec le contenant dans le contenu sous la forme d'un membre de la classe Piece, une pièce donnée n'appartenant jamais qu'à un et un seul plateau à la fois, voire, d'envisager la même chose pour les cases.

Cependant, cela implique des dépendances plus fortes, et il faut donc réfléchir sereinement à "ce qui est le mieux"

[bruno_pages]

...le contenant dans le contenu sous la forme d'un membre de la classe Piece

c'est pas loin de me rappeler quelque chose

[koala01]

c'est pas loin de me rappeler quelque chose

Effectivement...

Ce qui importe surtout, c'est de démontrer que, quelle que soit la solution envisagée, il n'est absolument pas nécessaire (au contraire, il serait dommageable) de recourir à une variable globale.

Après tout, une pièce ne peut exister que par l'échiquier auquel elle appartient, et l'échiquier ne peut exister que par... la partie qui l'utilise

[razily]

Bonjour ,

en tout cas merci
grâce à vous j'ai pu vraiment évoluer dans ce projet et découvrir la richesse de C++