Discussion :

[SAKDOSS]

Bonjour tout le monde,

J'ai un peu de mal en C++ et je n'arrive pas à trouver l'erreur du projet que je viens tout juste de commencer

Je souhaite créer une classe Arbre et une classe Foret.
Un Arbre contient une Foret .
Une Foret contient une Foret et un Arbre.

Voici les 4 classes correspondantes :

arbre.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef _ARBRE_H
#define	_ARBRE_H
 
#include "foret.hpp"
 
class Arbre{
      private :
              Foret foret();
 
      public :
             Arbre(char *);
};
#endif	/* _ARBRE_H */

arbre.cpp

Code :

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

1
2
3
#include "arbre.hpp"
 
Arbre::Arbre(char* chemin) {}

foret.hpp

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
#ifndef _FORET_H
#define	_FORET_H
 
#include"arbre.hpp"
 
class Foret {
	private :
	    Arbre premierArbre("plop");
	    Foret rest();
 
	public:
	    Foret();
 
};
#endif	/* _FORET_H */

foret.cpp

Code :

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

1
2
3
4
5
6
 
#include "foret.hpp"
 
Foret::Foret() {
 
}

Quand je compile :

Code :

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

1
2
3
4
gcc -Wall -pedantic -c arbre.cpp -o arbre.o
In file included from arbre.hpp:4,
                 from arbre.cpp:1:
foret.hpp:9: erreur: ‘Arbre’ does not name a type

Après une bonne heure de recherche je dois me résoudre à ne pas trouver l'erreur qui doit être très bète.


Auriez-vous une idée ?


PS : Si vous voyez des choses moches ou pas propre dans ces 4 fichiers, n'hésitez pas à critiquer même si ça n'a rien à voir.

[vikki]

Hello,
Deja, il me semble que tu va avoir un probleme d'inclusion multiple dans ton code (regarde la FAC pour ca, y'a une explication je crois). Ensuite, la ligne

Code :

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

1
2
 
Arbre premierArbre("plop");

n'a pas de sens dans la declaration d'une classe. A la rigueur,

Code :

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

1
2
 
Arbre premierArbre(const  char*);

mais je ne sais pas trop ce que tu veux faire

[SAKDOSS]

Je pensais que l'inclusion multiple serait réglée avec les "#ifndef".

Pour le "plop" ce n'est qu'un exemple pour tester le programme. Je ne pense pas que ce soit lui qui pose problème actuellement.

Sinon ce que je veux faire : une structure d'arbre.
Chaque Arbre contiendra un noeud et des fils.
L'ensemble des fils d'un arbre est une Foret.

Cela permet d'avoir des fonctions (de recherche, d'inclusion) relativement simple à coder bien que coûteuse car récursive.

[koala01]

Salut,

Le problème d'inclusion multiple n'est que partiellement géré par les gardes anti inclusion...

Ils permettent uniquement d'éviter les inclusions multiples lorsque qu'un même fichier d'en-tête est inclus plusieurs fois, de manière directe ou indirecte, dans un autre fichier...

Ici, tu te trouve dans le cadre, non pas d'une inclusion multiple, mais bien d'une inclusion circulaire:

Arbre.h inclus foret.h, qui inclus Abre.h qui inclus...

Le pire de l'histoire, c'est qu'on peut effectivement envisager le fait que, si la foret a réellement besoin de connaitre l'arbre, l'arbre ait effectivement besoin de connaitre la foret...(on parle de référence croisée entre deux classes)

Par chance, il se fait que, si, pour définir ta classe Foret, tu peux - effectivement - avoir besoin de la définition de la classe Arbre, tu peux te contenter d'une déclaration anticipée de Foret pour définir la classe Arbre:

La définition de Foret ne sera utile à Arbre que lorsque tu voudra accéder à des données de la foret au départ de l'arbre

[poukill]

Un arbre devra posséder une référence sur sa forêt.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#ifndef _ARBRE_H
#define	_ARBRE_H
 
#include "foret.hpp"
 
class Arbre{
      private :
              Foret& foret;
 
      public :
             Arbre(char *);
};
#endif	/* _ARBRE_H */

[koala01]

Un arbre devra posséder une référence sur sa forêt.

Ou un pointeur, si l'on envisage le fait qu'un arbre puisse ne pas faire partie d'une foret ...

(au fait, personne n'a remarqué l'horreur suivante dans le code SAKDOSS : )

Code :

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

1
2
3
class Arbre{
      private :
              Foret foret(); //<<ouch

Veux tu réellement déclarer une fonction privée nommée foret et renvoyant une instance de foret

Cela me semble vraiment suspect

[poukill]

(au fait, personne n'a remarqué l'horreur suivante dans le code SAKDOSS : )

Si, regarde mon code. J'ai mis une variable à la place de sa fonction !

[koala01]

Si, regarde mon code. J'ai mis une variable à la place de sa fonction !

Je voulais, en fait, dire que personne ne l'avait relevé

[SAKDOSS]

Merci pour vos réponses.

Je ne connaissais pas la déclaration anticipée. Et j'ai effectivement fait une erreur plutôt moche.


Juste une petite question. J'obtient les deux fichiers .hpp que voici en suivant le lien de la FAQ sur la déclaration anticipée :

arbre.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef _ARBRE_H
#define	_ARBRE_H
 
#include "foret.hpp"
 
class Arbre{
      private :
              Foret* foret;
 
      public :
             Arbre(char *);
};
#endif	/* _ARBRE_H */

foret.hpp

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
#ifndef _FORET_H
#define	_FORET_H
 
class Arbre;
 
class Foret {
	private :
	    Arbre* premierArbre;
	    Foret* reste;
 
	public:
	    Foret();
 
};
#endif	/* _FORET_H */

La ligne class Arbre; dans le fichier Foret.hpp me donne un peu l'impression de faire du bidouillage.

Ca ne choque pas ?

[koala01]

J'aurais personnellement fait l'inverse:

une déclaration anticipée de foret dans arbre.hpp et inclusion de arbre.hpp dans foret.hpp, voire, carrément, étant donné que les références circulaires sont toutes les deux des pointeurs, déclaration anticipée de "l'autre classe" dans les deux fichiers d'en-tête et inclusion des deux fichiers d'en-tête dans les fichiers d'implémentation

Et, non, cela ne choque absolument pas...

En effet, il faut faire la distinction entre la déclaration d'une classe et sa définition:

La déclaration d'une classe (class MaClass; ) permet juste au compilateur qu'il existe une classe du nom indiqué (MaClass, en l'occurence), alors que la définition de la classe permet au compilateur d'en connaitre le contenu.

Tant que le compilateur peut se contenter de savoir qu'une classe existe, la déclaration suffit

Il peut s'en contenter si:

• tu déclares une référence ou un pointeur sur un objet du type concerné et si
• tu n'essaye pas d'accéder à l'un des membres ou à l'une des fonctions membres de la classe

La raison est bien simple: un pointeur a une taille donnée (typiquement un nombre de bytes suffisant pour représenter l'ensemble des adresses mémoires accessibles), et une référence n'est - par définition - qu'un alias d'un objet existant par ailleurs, et n'utilise donc pas de mémoire propre (en réalité, si on regarde du coté du code assembleur généré, on se rend compte que c'est souvent géré comme un pointeur ) .

Le compilateur est donc en mesure de déterminer précisément la taille qu'il doit prévoir pour permettre la représentation d'un pointeur ou d'une référence.

Par contre, dés le moment où il s'agit de créer une instance de l'objet, ou d'accéder à un membre ou à une fonction membre de l'objet, le compilateur doit savoir quelle taille réserver en mémoire pour représenter l'objet et quel décalage appliquer, de l'adresse "de début" de l'objet, pour accéder au membre ou à la fonction membre que l'on souhaite exécuter: il a donc besoin de connaitre la totalité de la classe

[SAKDOSS]

Daccord. Merci pour cette explication.

Je vais effectivement utiliser la déclaration anticipée dans les deux classes.

J'ai cependant encore un problème.

Si par exemple dans la classe Arbre je veux ajouter une fonction qui retourne la Foret pointée par l'attribut "foret".
Je suis obligé de faire retourner à la fonction le pointeur "foret" ?
J'ai essayé de retourner directement la valeur pointée par "foret" et ça me met ce type d'erreur :

Code :

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

1
2
3
4
 
gcc -c arbre.cpp -o arbre.o
arbre.cpp: In member function ‘Foret Arbre::getForet()’:
arbre.cpp:4: erreur: return type ‘struct Foret’ is incomplete

Ce n'était pas très claire, voici les deux classes que j'ai modifiées :

arbre.hpp

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef _ARBRE_H
#define	_ARBRE_H
 
class Foret;
 
class Arbre{
      private :
              Foret* foret;
 
      public :
             Arbre(char *);
	     Foret getForet();
};
#endif	/* _ARBRE_H */

arbre.cpp

Code :

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

1
2
3
4
#include "arbre.hpp"
 
Arbre::Arbre(char* chemin) {}
Foret Arbre::getForet(){return *foret;}

Ma question est donc :
Puis-je retourner la Foret pointée par "foret" ou suis-je obligé de ne retourner que le pointeur "foret" ?

[koala01]

L'idéal, c'est de renvoyer une... référence sur la foret, voire une référence constante sur la foret...

Tu peux, bien sur, si tu le souhaites, renvoyer un pointeur sur foret, mais une chose est sur, si tu essaye de renvoyer une instance de foret, il faut la définition complete

Les possibilités qui te sont offertes sont donc:

Code :

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

1
2
3
4
5
6
7
8
/* soit tu renvoie un pointeur */
Foret* getForet(){return foret;}
/* soit tu renvoie une référence (constante ou non) sur la foret */
Foret & getForet(){return *foret;}
Foret const & getForet() const{return *foret;}
/* !!! il faut prévoir de lancer une exception si, pour une raison ou 
 * une autre, le pointeur foret est à NULL
 */

[SAKDOSS]

Ca marche.

Merci bien pour l'aide, et surement à bientôt.
Je pense que je serais amené à revenir sur ce forum dans les jours qui viennent...