[probleme] classe de base non définie

Version imprimable

bonjour,
je developpe un petit jeu d'echecs en c++,
nous avons des pieces féériques a implémenter, j'ai une classe piece qui est abstraite, une classe glisseur et une classe sauteur qui heritent de piece et qui sont egalement abstraite. Ensuite j'ai des classes du genre cavalier qui herite de sauter et tour et fou qui herite de glisseur. Pour les sauteurs tout fonctionne bien mais pour les glisseurs, visual studio me sort ca :

e:\programmation\3eme année\tpcxx2\tour.hxx(37) : error C2504: 'Glisseur' : classe de base non définie
e:\programmation\3eme année\tpcxx2\fou.hxx(40) : error C2504: 'Glisseur' : classe de base non définie

voici a quoi resemble tour.hxx :
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 #ifndef TOUR_HXX #define TOUR_HXX /* ** Include files */ #include <iostream> #include <string> using namespace std; #include "Piece.hxx" #include "Joueur.hxx" #include "Echiquier.hxx" #include "Glisseur.hxx" /* ** declaration de la classe Tour qui herite de Glisseur */ class Tour : public Glisseur { private: public: explicit Tour(int colonne_depart, int ligne_depart, int proprietaire); Tour(Piece *pion_promotion); //methode pour la promotion d'un pion en Tour ~Tour(); static bool verif_deplacement_static(int colonne_depart, int ligne_depart, int colonne_arrivee, int ligne_arrivee,Echiquier *echiquier, bool verif_echec); bool verif_deplacement(int colonne_depart, int ligne_depart, int colonne_arrivee, int ligne_arrivee,Echiquier *echiquier, bool verif_echec); }; #endif // TOUR_HXX

23/02/2007, 14h53
Médinoc

Je pense à un problème de gardes d'inclusion incorrects ou malencontreusement copiés-collés...

De plus, il ne faut JAMAIS mettre de using namespace directement dans un fichier d'en-tête.
23/02/2007, 14h58
Laurent Gomila

Ca peut être aussi une bête faute de syntaxe dans le nom de la classe, ou encore un problème d'inclusions cycliques.
23/02/2007, 15h42
aswat

je pense plutot a une inclusion cyclique...

pour le namespace, on nous as appris a le mettre la. Il faudrait le mettre ou normalement ?
23/02/2007, 15h50
Laurent Gomila

:faq:

Citation:

je pense plutot a une inclusion cyclique...

http://c.developpez.com/faq/cpp/?pag...erence_croisee

Citation:

pour le namespace, on nous as appris a le mettre la. Il faudrait le mettre ou normalement ?

http://c.developpez.com/faq/cpp/?pag...SPACE_no_using
23/02/2007, 15h52
r0d

Citation:

Envoyé par aswat

je pense plutot a une inclusion cyclique...

pour le namespace, on nous as appris a le mettre la. Il faudrait le mettre ou normalement ?

Il ne faut pas le mettre dans le fichier d'en-tête. Quand tu utilises un objet de la stl, il faut le spécifier explicitement => std::string.
De plus, dans ton cas, à moins que tu n'ais pas copié tout ton code, tu n'utilises pas la stl dans ton .h.

Sinon, c'est quoi les fichiers .hxx? Je demande ça parce qu'il est déconseillé d'inclure le moins possible de headers dans un autre header. Ca pose souvent des problème... d'inclusion cyclique par exemple ;)

ou la la .... alors les .hxx c'est parcequ'on a "obligation" de realiser un header par fichier .cxx., sinon le using namespace std il me semble qu'il est necessaire sous VMS, que nous avons a l'ecole, mais le probleme ne viens pas de la....

pour l'inclusion cyclique j'ai regardé mes fichiers j'ai un truc du genre:

cavalier --> sauteur --> Piece -->Joueur

Tour--> glisseur --> Echiquier --->Piece

ihm ---> analysejeu ---> Echiquier

voici le fichier Piece.hxx:

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
 
#ifndef PIECE_HXX
#define PIECE_HXX
 
/*
** Include files
*/
#include <iostream>
#include <string>
using namespace std;
 
#include "Joueur.hxx"
/*
** Déclaration des constantes
*/
#define NOIR 1
#define BLANC 0
 
class Echiquier;
 
/*
** declaration dela classe Piece
*/
class Piece
{
private:
	int valeur;			// valeur de la piece (dans le cas ou l'on souhaiterais compter les points)
	int ligne_courante;	 // position actuelle sur la grille
	int colonne_courante;
	bool deja_bouge;	// si la Piece a dejas bougée ou non
 
protected:	
	string type;
	int proprietaire;	// proprietaire de la piece (NOIR ou BLANC)
 
public:
	explicit Piece(int colonne_depart, int ligne_depart);
	explicit Piece();
	virtual ~Piece();// ce destructeur est virtuel car la classe Piece est 
					//abstraite et que d'autres classes heritent de Piece.
 
	bool deplacement(Echiquier *echiquier, int colonne_arrivee, int ligne_arrivee); //bool est le type de l'argument de retour
	void prise(Echiquier *echiquier,int colonne_arrivee,int ligne_arrivee);
	//cette methode est virtuelle pur et est donc implémentée par les classes filles
	virtual bool verif_deplacement(int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee,Echiquier *echiquier, bool verif_echec)=0;
 
	//getters et setters avec in-lineing
 
	void set_valeur(int valeur){this->valeur=valeur;}
	void set_proprietaire(int proprietaire){this->proprietaire=proprietaire;}
	void set_deja_bouge(bool deja_bouge){this->deja_bouge=deja_bouge;}
	void set_type(string type){this->type=type;}
	void set_colonne_courante(int colonne_courante){this->colonne_courante = colonne_courante;}
	void set_ligne_courante(int ligne_courante){this->ligne_courante = ligne_courante;}
 
	int get_colonne_courante(){return this->colonne_courante;}
	int get_ligne_courante(){return this->ligne_courante;}
	int get_valeur(){return this->valeur;}
	int get_proprietaire(){return this->proprietaire;}
	bool get_deja_bouge(){return this->deja_bouge;}
	string get_type(){return this->type;}
 
};
 
#endif // PIECE_HXX

J'insiste sur le fait qu'il faut éviter d'inclure des headers dans les headers. Par exemple, prenons le code que tu as fournis dans ton premier post:
Code:

1 2 3 4 5 6 7 [...] #include "Piece.hxx" // tu ne te sers que de pointeurs sur Piece. il te suffis donc de déclarer la classe #include "Joueur.hxx" // tu ne te sers pas ce la classe Joueur dans ce fichier, donc pas besoin #include "Echiquier.hxx" // même remarque que pour Piece #include "Glisseur.hxx" // celui-ci, en revanche, est indispensable puisque ta classe en hérite [...]
Ce qui donne, aprés correction et sans avoir besoin de modifier le reste du code:
Code:

1 2 3 4 5 6 7 [...] #include "Glisseur.hxx" class Piece; //il te faudra sans doute inclure Piece.hxx dans Tour.cpp class Echiquier; //même remarque [...]
Hope it helps.

edit: idem pour la classe Joueur dans Piece.hxx: tu ne t'en sers pas dans ce fichier, ne l'inclus donc pas. Si tu en as besoin dans le .cpp, inclus-le dans le .cpp, mais pas dans le .h.

j'ai suivis ton conseil et j'ai donc enlevé les #include, voici donc mon fichier

tour.hxx:

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
#ifndef TOUR_HXX
#define TOUR_HXX
 
/*
** Include files
*/
#include <iostream>
#include <string>
using namespace std;
 
#include "Glisseur.hxx"
 
class Piece;
class Echiquier;
 
/*
** declaration de la classe Tour qui herite de Glisseur
*/
class Tour : public Glisseur
{
private:
 
public:
	explicit Tour(int colonne_depart, int ligne_depart, int proprietaire);
	Tour(Piece *pion_promotion); //methode pour la promotion d'un pion en Tour
	~Tour();
	static bool verif_deplacement_static(int colonne_depart, int ligne_depart, int colonne_arrivee, int ligne_arrivee,Echiquier *echiquier, bool verif_echec);
	bool verif_deplacement(int colonne_depart, int ligne_depart, int colonne_arrivee, int ligne_arrivee,Echiquier *echiquier, bool verif_echec);
};
 
#endif // TOUR_HXX

piece.hxx

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
#ifndef PIECE_HXX
#define PIECE_HXX
 
/*
** Include files
*/
#include <iostream>
#include <string>
using namespace std;
 
//#include "Joueur.hxx"
/*
** Déclaration des constantes
*/
#define NOIR 1
#define BLANC 0
 
class Echiquier;
class Joueur;
 
/*
** declaration dela classe Piece
*/
class Piece
{
private:
	int valeur;			// valeur de la piece (dans le cas ou l'on souhaiterais compter les points)
	int ligne_courante;	 // position actuelle sur la grille
	int colonne_courante;
	bool deja_bouge;	// si la Piece a dejas bougée ou non
 
protected:	
	string type;
	int proprietaire;	// proprietaire de la piece (NOIR ou BLANC)
 
public:
	explicit Piece(int colonne_depart, int ligne_depart);
	explicit Piece();
	virtual ~Piece();// ce destructeur est virtuel car la classe Piece est 
					//abstraite et que d'autres classes heritent de Piece.
 
	bool deplacement(Echiquier *echiquier, int colonne_arrivee, int ligne_arrivee); //bool est le type de l'argument de retour
	void prise(Echiquier *echiquier,int colonne_arrivee,int ligne_arrivee);
	//cette methode est virtuelle pur et est donc implémentée par les classes filles
	virtual bool verif_deplacement(int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee,Echiquier *echiquier, bool verif_echec)=0;
 
	//getters et setters avec in-lineing
 
	void set_valeur(int valeur){this->valeur=valeur;}
	void set_proprietaire(int proprietaire){this->proprietaire=proprietaire;}
	void set_deja_bouge(bool deja_bouge){this->deja_bouge=deja_bouge;}
	void set_type(string type){this->type=type;}
	void set_colonne_courante(int colonne_courante){this->colonne_courante = colonne_courante;}
	void set_ligne_courante(int ligne_courante){this->ligne_courante = ligne_courante;}
 
	int get_colonne_courante(){return this->colonne_courante;}
	int get_ligne_courante(){return this->ligne_courante;}
	int get_valeur(){return this->valeur;}
	int get_proprietaire(){return this->proprietaire;}
	bool get_deja_bouge(){return this->deja_bouge;}
	string get_type(){return this->type;}
 
};
 
#endif // PIECE_HXX

glisseur.hxx

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
#ifndef GLISSEUR_HXX
#define GLISSEUR_HXX
 
/*
** Fichiers et bibliothèques inclus
*/
#include <iostream>
#include <string>
 
using namespace std;
 
#include "Echiquier.hxx"
 
/*
** Déclaration des constantes
*/
#define NOMBRE_COLONNES 9
#define NOMBRE_LIGNES 9
 
//class Echiquier;
/*
** Déclaration de la classe Glisseur
*/
class Glisseur : public Piece
{
private:
 
protected:
 
public:
	explicit Glisseur(int colonne_depart, int ligne_depart, int proprietaire);
	explicit Glisseur();
	virtual ~Glisseur();
	static bool glisser(int distance, int diff_colonne, int diff_ligne, int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee, Echiquier *echiquier);
	virtual bool verif_deplacement(int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee,Echiquier *echiquier, bool verif_echec)=0;
};
 
#endif // GLISSEUR_HXX

echiquier.hxx

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
#ifndef ECHIQUIER_HXX
#define ECHIQUIER_HXX
 
/*
** Fichiers et bibliothèques inclus
*/
#include <iostream>
#include <string>
 
#include "Piece.hxx"
#include "Tour.hxx"
#include "Cavalier.hxx"
#include "Fou.hxx"
#include "Roi.hxx"
#include "Dame.hxx"
#include "Pion.hxx"
#include "Cardinal.hxx"
#include "Amazone.hxx"
#include "Chameau.hxx"
#include "Alfil.hxx"
#include "Girafe.hxx"
#include "Dabbabah.hxx"
#include "Ecureuil.hxx"
 
using namespace std;
 
/*
** Déclaration des constantes
*/
#define NOIR 1
#define BLANC 0
#define NOMBRE_COLONNES 9
#define NOMBRE_LIGNES 9
#define DECALAGE_CODE_ASCII 48
#define INVERSION_LIGNES_FEN 7
 
/*
** Déclaration de la classe Echiquier
*/
class Echiquier
{
private:
 
//L'échiquier est un table de pièces de taille 9 par 9
//Il est vrai qu'un tableau de taille 8 par 8
//aurait utilisé moins de mémoire, mais nous préférons la numérotation de 1 à 8, 
//les colonnes et lignes d'indices 0 étant inutilisées.
Piece *echiquier[NOMBRE_COLONNES][NOMBRE_LIGNES];
 
public:
	explicit Echiquier();
   ~Echiquier();
    bool init_echiquier(Joueur *joueur_blanc, Joueur *joueur_noir, string commande_fen);
	bool verification_echec(Joueur *joueur);	
 
   void set_case(int colonne_courante, int ligne_courante, Piece *piece )
   {
		echiquier[colonne_courante][ligne_courante] = piece;
   }
   Piece *get_case(int colonne_arrivee, int ligne_arrivee)
   {
		return echiquier[colonne_arrivee][ligne_arrivee];
   }
};
 
#endif // ECHIQUIER_HXX

sauteur.hxx:

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
#ifndef SAUTEUR_HXX
#define SAUTEUR_HXX
 
/*
** Fichiers et bibliothèques inclus
*/
#include <iostream>
#include <string>
 
using namespace std;
 
#include "Piece.hxx"
 
/*
** Déclaration des constantes
*/
#define NOMBRE_COLONNES 9
#define NOMBRE_LIGNES 9
 
/*
** Déclaration de la classe Sauteur
*/
class Sauteur : public Piece
{
private:
 
protected:
	int tableau[2]; //represente les coordonnées d'arrivée possibles 
 
public:
	explicit Sauteur(int colonne_depart, int ligne_depart, int proprietaire);
	explicit Sauteur();
	virtual ~Sauteur();
	static bool sauter(int tableau[2], int colonne_depart, int ligne_depart, int colonne_arrivee, int ligne_arrivee);
	virtual bool verif_deplacement(int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee,Echiquier *echiquier, bool verif_echec)=0;
};
 
#endif // SAUTEUR_HXX

Ca ne veus toujours pas compiler et pourtant pas d'erreurs sur sauteur, juste sur glisseur, la difference entre les deux fichiers c'est le #include "Echiquier.hxx" dont j'ais besoin pour ma methode glisser.

Merci de m'aider a rendre mon code plus propre et surtout a le faire compiler... :)

23/02/2007, 18h57
Laurent Gomila

Tu n'as pas besoin d'inclure Echiquier.hxx dans Glisseur.hxx, puisque tu ne déclare qu'un pointeur. C'est ça qui te créait la dépendance cyclique.

je doit bien l'inclure quelque part puisque je l'utilise dans glisseur.cxx

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
/*
** Fichiers et bibliothèques inclus
*/
#include "Glisseur.hxx"
 
//Constructeur
Glisseur :: Glisseur(int colonne_depart, int ligne_depart, int proprietaire) : Piece(colonne_depart,ligne_depart)
{
	this->proprietaire = proprietaire;
}
Glisseur::Glisseur() : Piece()
{
}
 
//Destructeur
Glisseur :: ~Glisseur()// ce destructeur est virtuel car la classe Glisseur est abstraite et que 
{				// d'autres classes heritent de Glisseur.
}
 
bool Glisseur::glisser(int distance, int diff_colonne, int diff_ligne, int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee, Echiquier *echiquier)
{
	bool deplacement_valide = true;
	//on verifie que le mouvement en lui même est bien valide
	for (int i = 1; i < distance; i++)//pour chaque ligne qui sépart la piece de la destination sauf la case de destination
	{
		if (echiquier->get_case(colonne_depart + (diff_colonne*i),ligne_depart + (diff_ligne*i)) != NULL) //si il y a une piece sur le chemin, le deplacement n'est pas valide
		{
			deplacement_valide = false;
		}
	}
	if (echiquier->get_case(colonne_arrivee,ligne_arrivee) != NULL) //si la case d'arrivée n'est pas nulle, on test qu'elle ne nous appartient pas, sinon le deplacement n'est pas valide
	{
		if (deplacement_valide 
			&& (echiquier->get_case(colonne_arrivee,ligne_arrivee)->get_proprietaire()) == (echiquier->get_case(colonne_depart,ligne_depart)->get_proprietaire()))
		{
			deplacement_valide = false; //impossible de prendre une de ces propres pieces
		}
	}
 
	return deplacement_valide;
}

23/02/2007, 19h41
urchin

ouais, mais pas dans le header. Je pense qu'on te suggérait de faire une déclaration en avant dans le header ("class Echiquier;" dans ton Glisseur.h) puis d'inclure "Echiquier.h" dans le "Glisseur.cxx"

je rêve ca marche !!!!

voici le code:

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
#ifndef GLISSEUR_HXX
#define GLISSEUR_HXX
 
/*
** Fichiers et bibliothèques inclus
*/
#include <iostream>
#include <string>
 
using namespace std;
 
#include "Piece.hxx"
/*
** Déclaration des constantes
*/
#define NOMBRE_COLONNES 9
#define NOMBRE_LIGNES 9
 
class Echiquier;
 
/*
** Déclaration de la classe Glisseur
*/
class Glisseur : public Piece
{
private:
 
protected:
 
public:
	explicit Glisseur(int colonne_depart, int ligne_depart, int proprietaire);
	explicit Glisseur();
	virtual ~Glisseur();
	static bool glisser(int distance, int diff_colonne, int diff_ligne, int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee, Echiquier *echiquier);
	virtual bool verif_deplacement(int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee,Echiquier *echiquier, bool verif_echec)=0;
};
 
#endif // GLISSEUR_HXX

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
/*
** Fichiers et bibliothèques inclus
*/
#include "Glisseur.hxx"
#include "Echiquier.hxx"
 
//Constructeur
Glisseur :: Glisseur(int colonne_depart, int ligne_depart, int proprietaire) : Piece(colonne_depart,ligne_depart)
{
	this->proprietaire = proprietaire;
}
Glisseur::Glisseur() : Piece()
{
}
 
//Destructeur
Glisseur :: ~Glisseur()// ce destructeur est virtuel car la classe Glisseur est abstraite et que 
{				// d'autres classes heritent de Glisseur.
}
 
bool Glisseur::glisser(int distance, int diff_colonne, int diff_ligne, int colonne_depart,int ligne_depart,int colonne_arrivee,int ligne_arrivee, Echiquier *echiquier)
{
	bool deplacement_valide = true;
	//on verifie que le mouvement en lui même est bien valide
	for (int i = 1; i < distance; i++)//pour chaque ligne qui sépart la piece de la destination sauf la case de destination
	{
		if (echiquier->get_case(colonne_depart + (diff_colonne*i),ligne_depart + (diff_ligne*i)) != NULL) //si il y a une piece sur le chemin, le deplacement n'est pas valide
		{
			deplacement_valide = false;
		}
	}
	if (echiquier->get_case(colonne_arrivee,ligne_arrivee) != NULL) //si la case d'arrivée n'est pas nulle, on test qu'elle ne nous appartient pas, sinon le deplacement n'est pas valide
	{
		if (deplacement_valide 
			&& (echiquier->get_case(colonne_arrivee,ligne_arrivee)->get_proprietaire()) == (echiquier->get_case(colonne_depart,ligne_depart)->get_proprietaire()))
		{
			deplacement_valide = false; //impossible de prendre une de ces propres pieces
		}
	}
 
	return deplacement_valide;
}

Bon maintenant que ca marche j'aimerais savoir quelle demarche utiliser pour les using namespace std; si j'ai bien compris, a moins d'utiliser un cin, cout dans les headers (je ne le fais jamais), il faut pas que je le mette dans le hearder, mais belle et bien dans le fichier source, c'est ca ?

merci beaucoup pour le coup de main que vous me donnez,
Aswat

23/02/2007, 20h20
urchin

oui, tu peux au choix le mettre dans le cxx...ou bien tout simplement t'en passer complètement (utiliser std::cout au lieu de cout etc...)
23/02/2007, 20h42
aswat

désolé pour le doublon, je comprends pas comment cela est arrivé.
Ok, je vais faire les modifs pour le namespace std.
Merci a vous tous,

Aswat