Probleme de forward declaration

Voila, pour eviter un include, je veux faire une forward declaration.
Le probleme c'est que ca concerne une nested class :

class A;
class A::B; // compil error : expected type-name

void myFunction(const A::B&);

Comment faire pour bien ecrire une predeclaration d'une classe imbriquee ?

Tu ne peux pas. A partir du moment où tu essayes d'accéder à un champ/type/fonction d'une classe A, il faut que celle-ci ait été définie. Donc nécessité d'un #include.

Salut,

Par contre, rien ne t'empêche normalement de faire une déclaration anticipée de ta classe imbriquée:

Code:

---

1 2 3 4

class A; class A::B;   void MaFonction(/*const*/ A::B&);

---

(attention: la déclaration imbriquée de B doit être effectuée dans la partie publique de A ;))

Citation:

---

Envoyé par koala01

Salut,

Par contre, rien ne t'empêche normalement de faire une déclaration anticipée de ta classe imbriquée:

Code:

---

1 2 3 4

class A; class A::B;   void MaFonction(/*const*/ A::B&);

---

(attention: la déclaration imbriquée de B doit être effectuée dans la partie publique de A ;))

---

Ben, c'est exactement ce que j'ai fait.
Et B est bien publique dans A

Je viens de vérifier... la déclaration anticipée ne fonctionne effectivement pas dans le cadre d'un classe imbriquée. Au temps pour moi :oops:

Ceci dit, tu n'évitera pas l'include à un moment où un autre, même dans le cas où une déclaration anticipée apparait :P

Dés le moment où tu veux utiliser une structure définie, il n'y a rien à faire, il faut que l'unité de compilation dispose de... la définition réelle de cette structure:

• pour en connaître les noms des différents membres
• pour en connaître les noms des différentes méthodes
• pour en connaître la taille

Tu ne peux d'ailleurs envisager sereinement la déclaration anticipée que si tu n'a pas besoin du type complet avant qu'il n'apparaisse.

Ainsi, un code du genre de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#ifndef A_H #define A_H class B;   class A { public: A(B&); virtual ~A(); const B GetAsB(); protected: private: int v; }; #endif // A_H

---

fonctionnera avec un fichier d'implémentation sous la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include "A.h" #include "B.h"   A::A(B& b):v(b.GetVal()) {   } A::~A() {   } const B A::GetAsB() { return B(v); }

---

(sous réserve, évidemment, de l'existence du fichier B.h) alors qu'une classe du genre de

Code:

---

1 2 3 4 5 6 7 8 9

class A { public: explicit A(const B&); ~A(); private: B b; };

---

nécessitera de connaître la définition complète de B pour être en mesure de créer la classe A.

Il s'en suit qu'il faudra soit inclure B.h avant de définir la classe A, soit définir les deux classes dans le même fichier, mais en définissant B avant A :roll:

[EDIT]Par contre, la taille d'un pointeur étant d'office connue, rien ne t'empêcherait de prévoir une classe sous la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10

class B; class A { public: A(B*); ~B(); private: B* b; };

---

et de ne prévoir la définition complète de la classe B qu'après la classe A (ou via inclusion de B.h dans le fichier d'implémentation)

Mais, quoi qu'il en soit, il semble raisonnable d'envisager le fait que tu auras de toutes façons besoin de connaître l'intégralité de la classe B pour implémenter les différentes méthodes de la classe A :P

Faudrait déja savoir pour quelle raison tu veux déclarer ta fonction avant de définir ta classe, je n'en vois du tout l'utilité.
D'après mon expérience, je dirais que les déclarations anticipées ne sont utiles que dans le cas d'interdépendance entre des classes (notamment avec les classes amies), et aussi qu'il vaut vraiment mieux les déclarer dans le même header (j'ai déja passé des heures à essayer de trouver un barème quelconque pour les dépendances inter-fichiers, j'ai fini par laisser tomber).

Citation:

---

Envoyé par zais_ethael

Faudrait déja savoir pour quelle raison tu veux déclarer ta fonction avant de définir ta classe, je n'en vois du tout l'utilité.
D'après mon expérience, je dirais que les déclarations anticipées ne sont utiles que dans le cas d'interdépendance entre des classes (notamment avec les classes amies), et aussi qu'il vaut vraiment mieux les déclarer dans le même header (j'ai déja passé des heures à essayer de trouver un barème quelconque pour les dépendances inter-fichiers, j'ai fini par laisser tomber).

---

Non...

La déclaration anticipée peut, tout simplement, servir à éviter d'exposer toutes les dépendances dans le fichiers d'en-tête...

Avec QT, par exemple, il est "d'usage" de travailler sous une forme proche de

Code:

---

1 2 3 4 5 6 7 8 9 10

#ifdef ... #define ...   class Dependance1; class Dependance2; /*...*/ class MaClasse { /*...*/ };

---

et de ne placer les fichiers inclus que dans le fichier d'implémentation.

Bon ou mauvais, cela permet malgré tout de ne pas forcer la dépendance sur le fichier d'en-tête :P:roll:

Mais ça va faire un méchant foutoir dans les inclusions de fichier, avec par exemple l'obligation d'inclure le fichier contenant la déclaration avant celui contenant la définition (si on veut utiliser les deux dans la même unité de programmation). Et normalement, ça ne marchera pas non plus si on a deux fichiers à inclure contenant chacun leur déclaration.

J'ai l'impression que tu ne comprend pas bien les différents thermes...

Une délcaration anticipée, permet juste de dire qu'une classe existe, et se trouve généralement dans un fichier d'en-tête sous une forme proche de

Code:

---

class LaClass;

---

La définition d'une classe indique le contenu de cette classe, se trouve dans le fichier d'en-tête et fournit la déclaration des membres et méthodes sous la forme de

Code:

---

1 2 3 4 5 6 7 8

class LaClass { public: LaClass(); /* déclaration du constructeur */ ~LaClass(); /* déclaration du destructeur */ private: int m; /*déclaration du membre nommé m */ };

---

L'implémentation de la classe consiste à fournir la définition /l'implémentation des méthodes de cette classe et ne doit normalement pas se trouver dans le fichier d'en-tête (sauf cas particulier), mais dans un fichier "d'implémentation" séparé (typiquement, un fichier avec l'extension *.cpp)

Un fichier portant l'extension *.cpp ne doit jamais être inclus dans un fichier d'en-tête, mais doit, au minimum, inclure les fichiers dans lesquels sont définies les classes dont il doit définir les méthodes.

Si un fichier d'implémentation doit se trouver dans un fichier d'en-tête, comme par exemple en ce qui concerne les classes template, il est très largement conseillé d'éviter l'extension *.cpp pour éviter, justement, toute confusion.

Enfin, pour pouvoir instancier en mémoire un objet du type d'une classe donnée, et, à moins de se contenter d'un pointeur au départ duquel on n'essayerait pas d'accéder à un membre ou à une méthode, il faut disposer de la définition complète de la classe en question (mais pas de l'implémentation de ses méthodes ;))
Ainsi, tu pourrait très bien envisager un fichier "A.h" contenant

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#ifndef A_H #define A_H class B;   class A { public: A(B*); virtual ~A(); B* GetB(); protected: private: B* v; }; #endif // A_H

---

qui, comme il ne fait qu'utiliser un pointeur de type B n'a pas besoin, en l'état, d'autre chose que le fait de savoir que la classe B existe.

Le fichier d'implémentation prendrait la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include "A.h"   A::A(B* b):v(b) {   } A::~A() {   } const B* A::GetB() { return v; }

---

Tu pourrait envisager une classe B héritant de A et dont le fichier d'en-tête prendrait la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#ifndef B_H #define B_H #include "A.h" /* le fait qu'il y ait héritage fait qu'il faut disposer de la   * définition complete   */ class B:public A { public: B(B* b, int val); ~B(); int Value(); private: int val; }; #endif // B_H

---

et dont le fichier d'implémentation prendrait la forme de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include "B.h" B::B(B* b, int val):A(b),val(val) { //ctor }   B::~B() { //dtor } int B::Value() { return val; }

---

Là où les choses se compliqueraient, c'est dans le cas où tu voudrait ajouter une méthode telle que

Code:

---

1 2	B& Reference();

---

directement dans la classe A, en prévoyant de la définir sous une forme proche de

Code:

---

1 2 3 4

B& A::Reference() { return *v; };

---

En effet, comme cette fonction ne renvoie pas un pointeur mais bel et bien une instance de l'objet de type B, la fonction (et donc le fichier dans lequel elle est définie) doit... disposer de la définition complete du type B :roll:

On entre de plein pied dans le problème d'inclusions cycliques( A qui inclut B et B qui inclut A).

On ne peut donc pas mettre l'inclusion de B.h dans A.h, et, pour que A.cpp puisse disposer de la définition complète de B, on doit donc effectuer l'inclusion... directement dans A.cpp ;)

Wah, merci pour ce cours sur le C++. Oui, je sais très bien ce que sont les déclarations/définitions/implémentation.
Je pensais que plusieurs déclarations/définitions de classes imbriquées dans n'importe quel ordre poseraient problème, mais après avoir testé deux secondes je viens de me rendre compte que ce n'était pas le cas :D. Donc fais comme si j'avais rien dit.

Sinon:

Citation:

---

Envoyé par koala01

Code:

---

1 2 3 4

B& A::Reference() { return *v; };

---

En effet, comme cette fonction ne renvoie pas un pointeur mais bel et bien une instance de l'objet de type B, la fonction (et donc le fichier dans lequel elle est définie) doit... disposer de la définition complete du type B :roll:

---

Ou vois tu une instance toi? Je ne vois qu'une réfèrence. Teste, et tu verras que déclarer cette fonction fonctionne très bien avec une simple déclaration de B.

Citation:

---

Envoyé par zais_ethael

Ou vois tu une instance toi?

---

Ici :

Code:

---

1 2	return *v;

---

Citation:

---

Envoyé par zais_ethael

]Je ne vois qu'une réfèrence. Teste, et tu verras que déclarer cette fonction fonctionne très bien avec une simple déclaration de B.

---

La déclaration de la fonction oui ; la définition non.