Discussion :

[Zakaima]

Bonjours,
// b.h

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
 
template<class T>
class A;
 
class B
{
    void function(A<double>& );
}
 
//b.cpp
 
void B::function(A<double>& a)
{
     a.fonctionQuelconque();
}

Mon problème est quand je fais une déclaration forward d'une template, le compilateur n'arrive pas à accéder au fonction de cette classe, du moins c'est mon cas. Est ce normale ?

[koala01]

Salut,

Bonjours,
// b.h

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
 
template<class T>
class A;
 
class B
{
    void function(A<double>& );
}
 
//b.cpp
 
void B::function(A<double>& a)
{
     a.fonctionQuelconque();
}

Mon problème est quand je fais une déclaration forward d'une template, le compilateur n'arrive pas à accéder au fonction de cette classe, du moins c'est mon cas. Est ce normale ?

Oui, bien sur...

Quand tu écris

Code :

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

1
2
template <typename T>
class A;

tu dis au compilateur "ne t'en fais pas de trouver A<XXX> dans le code, je t'assure que c'est quelque chose qui existe.

Le problème, c'est que tu ne fais rien d'autre que de décalrer le fait qu'il existe une classe (template) nommée A.

Pour que le compilateur puisse utiliser le contenu de la classe A, il doit connaitre ce contenu, et, pour y arriver, il a besoin de la définition de la classe (en gros de l'inclusion du fichier d'en-tête dans lequel la classe est définie)

Dans le B.h, tu peux donc effectivement te contenter de la déclaration anticipée (juste pour que le compilateur sache que la classe A existe), mais dans B.cpp, tu as besoin de la définition complète

[Zakaima]

Donc dans mon cas il est plus intéressant de faire un include que une forward declaration ?

[ternel]

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
//b.h
template<class T>
class A;

class B
{
    void function(A<double>& );
}

//b.cpp
#include A.h
void B::function(A<double>& a)
{
     a.fonctionQuelconque();
}

Dans les entêtes, la déclaration anticipée est mieux (moins de dépendances...)
Mais quand le code est requis, il faut les inclusions.

[Zakaima]

Merci pour l'explication,

j'essaye d'améliorer ma façon d'inclure mes fichier, de pouvoir le faire de la façon la plus intelligente et optimale. Sur internet j'ai lu ceci :

- do nothing if: A makes no references at all to B
- do nothing if: The only reference to B is in a friend declaration
- forward declare B if: A contains a B pointer or reference: B* myb;
- forward declare B if: one or more functions has a B object/pointer/reference
as a parementer, or as a return type: B MyFunction(B myb);
- #include "b.h" if: B is a parent class of A
- #include "b.h" if: A contains a B object: B myb;

Mais en générale quand on fait une référence à une classe dans une autre on utilise quasiment toujours c'est fonction membres. Donc les forward déclaration deviennent très peu utile ?

[oodini]

Mais en générale quand on fait une référence à une classe dans une autre on utilise quasiment toujours c'est fonction membres. Donc les forward déclaration deviennent très peu utile ?

C'est en général dans des .h(pp), là où il n'y a souvent pas d'implémentations (sauf en cas d'utilisations de templates), qu'elles se révèlent très utiles.
Si tes .h(pp) ont des inclusions inutiles, et que ces mêmes .h(pp) sont inclus dans de nombreux fichiers, elles deviennent de précieux alliés pour réduire les temps de compilation.

[koala01]

Merci pour l'explication,

j'essaye d'améliorer ma façon d'inclure mes fichier, de pouvoir le faire de la façon la plus intelligente et optimale. Sur internet j'ai lu ceci :

- do nothing if: A makes no references at all to B
- do nothing if: The only reference to B is in a friend declaration
- forward declare B if: A contains a B pointer or reference: B* myb;
- forward declare B if: one or more functions has a B object/pointer/reference
as a parementer, or as a return type: B MyFunction(B myb);
- #include "b.h" if: B is a parent class of A
- #include "b.h" if: A contains a B object: B myb;

Mais en générale quand on fait une référence à une classe dans une autre on utilise quasiment toujours c'est fonction membres. Donc les forward déclaration deviennent très peu utile ?

La déclaration anticipée permet, comme je l'ai expliqué, uniquement au compilateur de savoir qu'il existe un symbole nommé <nom_de_la_classe>.

De cette manière, il ne s'inquiètera pas de trouver ce symbole comme nom de type pour un argument, par exemple.

L'idéal reste de recourir à la déclaration anticipée "chaque fois que possible", c'est à dire:
Tant que tu n'as pas besoin de connaitre le contenu de la classe par exemple:

1. Quand tu veux déclarer une fonction qui prend en argument une référence ou un pointeur sur un objet du type concerné
2. Quand tu veux déclarer un membre qui est un pointeur ou une référence sur un objet du type concerné

En effet, si tu rajoutes tout simplement les fichiers d'en-tête de tous les types dont ta classe a besoin, il t'arrivera régulièrement d'être confronté à un problème de dépendances circulaires : un fichier d'en-tête XXX.h qui a besoin du fichier d'en-tête YYY.h qui a lui-même besoin du fichier XXX.h de manière directe ou indirecte

De plus, il faut savoir que le préprocessing des fichiers d'en-tête est un processus qui prend énormément de temps, et qu'il n'est pas rare de trouver un fichier AAA.h qui inclut un fichier BBB.h qui inclut lui-même un fichier CCC.h qui inclut...(on peut continuer longtemps comme ca ) et que tous les fichiers doivent alors être préprocessés.

Il et d'autant plus dommage d'avoir 150 fichier à préprocesser si tout ce qui nous intéresse, dans le cas d'une classe AAA, c'est de pouvoir savoir qu'une classe XXX dispose de la fonction doIt() (seule fonction de XXX réellement utilisée dans le code de AAA )

Par contre, il n'y a en effet pas le choix : la déclaration anticipée permet de retarder le moment où l'incluision du fichier sera nécessaire, mais il faudra bien que le compilateur sache, à un moment ou à un autre, que la fonction doIt() fait bel et bien partie de l'interface de la classe XXX pour accepter (après avoir vérifier la concordance de type des éventuels argument) le fait que l'on fasse appel à cette fonction


A ce moment là, l'inclusion du fichier d'en-tête devient incontournable

[Zakaima]

Merci beaucoup pour vos explications la chose devient plus claire !