Version imprimable
Bonjour.
Tout est dit dans le titre.
J'ai une class template que j'aimerais utiliser en tant que std::shared_ptr < ClassTemplate < OBJECT_X > > _maClass ; par plusieurs objects.
Quand je l'utilise dans un seul object, ca marche, et j'ai accès au template. Mais quand j'essaye de faire de même avec une autre class, il me dit error :
'ClassTemplate' was not declared in this scopeé'.
Pensez vous que cela soit normal ?
Merci si vous pouvez m'aider :)
Prions pour que ma boule de cristal soit assez réparé.
A priori, ca manque d'un include.
Et éventuellement, d'utiliser le nom qualifié (avec les namespaces, donc).
Oui, bien vu.
En fait ca manquait pas d'un include, il y en avait un de trop. Je me suis un peu embrouillé et j'avais oublié d'enlever un #include inutile dans mon template qui cassait la hierarchie.
Bref, en fait ca marche.
Merci ;)
Ca veut dire que le fichier inclus par cet include en trop est sale.
essaie de le nettoyer.
Un include ne doit jamais pourrir un code:
- avoir une garde contre la double inclusion
- ne pas contenir de using (hors d'une classe, s'entend)
- de préférence définir son contenu dans un namespace
- Si possible, ne pas définir de macro. En général, il vaut mieux les définir dans le .cpp définissant ce que l'en-tête déclare.
- Toute fonction libre définie doit être marquée inline.
:aie:
Je vois que j'ai encore beaucoup de choses à apprendre. Merci pour ces conseils. Je vais veiller à les appliquer au mieux.
ps : quel est le risque si on utiliser 2 fois le même include dans une hierarchie ?
Que veux tu dire par "dans une hiérarchie"?
Un #include, c'est une commande au préprocesseur, reconnaissable au # en début de ligne.
Quand on demande au compilateur de faire son travail, il y a trois grandes étapes:
- le preprocessing (un mot français?)
- la compilation en tant que telle
- l'édition de lien
Par exemple, la commande gcc main.cpp lib.cpp -o programme se décompose ainsi:
- preprocessing de main.cpp
- compilation du résultat
- preprocessing de lib.cpp
- compilation du résultat
- concaténation des deux fichiers compilés et édition de lien.
La phase du préprocesseur consiste à parcourir ligne à ligne le fichier source.
Pour l'essentiel il a deux fonctions: remplacer les macros qu'il trouve, et executer les commandes qui lui sont adressées (lignes commençant par un #).
Une fois ce traitement fait, il copie la ligne dans le fichier résultat.
Le traitement d'un #include, c'est juste d'insérer avant la prochaine ligne le contenu du fichier inclus.
Le fichier résultat contient un code source atomique, nommé par la norme unité de compilation.
La conséquence, c'est que le code qui sert au compilateur ne contient réellement qu'un seul fichier, sans include.
C'est la que le mot clé extern prend son sens. (et le fait que toute déclaration de fonction est extern)
extern signifie que la chose ainsi marquée n'est que déclarée, et sera défini dans une unité de compilation externe à la présente.
La règle de la définition unique dit que chaque chose utilisée doit être définie une et une seule fois dans l'ensemble du programme.
C'est pourquoi un include ne doit pas contenir de définitions: pour éviter d'avoir la définition d'une même chose dans plusieurs unités différentes.
inline permet justement de circonvenir à cette règle.
Après la compilation de chaque unité de compilation, l'édition de liens fait le lien entre chaque symbole simplement déclaré et sa définition unique.
C'est pour ca que tu peux avoir des erreurs d'éditions de liens dites "undefined reference to ..." avec ... un nom bizarre.
Tout ca pour dire qu'un #include ne connais pas le code.
Ce n'est pas son problème.
Le C++ en lui-même viendra plus tard.
En fait, tu pourrais même utiliser le préprocesseur C++ avec des fichiers ne contenant pas du C++, mais autre chose, comme des fichiers de configuration.
Montre nous un peu plus de code, contenant tes deux includes, et le fichier inclus, si possible.
On pourra te dire le risque potentiel.
ps: merci bacelar pour la correction.
Citation:
Par exemple, la commande gcc main.cpp lib.cpp -o programme se décompose ainsi:
•preprocessing de main.cpp
•compilation du résultat
•preprocessing demain.cpplib.cpp
•compilation du résultat
•concaténation des deux fichiers compilés et édition de lien.