Discussion :

[akirira]

Bonjour,
J'ai un problème d'instanciation de template, qui me semble ressembler à ce qui est évoqué ici:
http://www.developpez.net/forums/d10...ion-templates/

Pour un "petit" projet, je n'arrive pas à compiler mon code avec GCC, composé pour l'instant d'une petite dizaine de fichiers.
Pour faire court, j'ai deux classes A et B, qui dérivent toutes deux de ROOT<TYPE>.

J'ai donc un magnifique #include "root.hpp" dans mes deux déclarations de classes A et B. Dans ce fichier se trouve évidemment le code de cette classe (enfin, dans un fichier séparé quand même, mais qui est inclus à la fin de root.hpp)
Après compilation correcte du code des 2 classes, le linker râle parce que le code de la classe ROOT est en double:

Code :

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

1
2
3
4
 
obj\src\A.o:A.cpp:(.text+0xfe): multiple definition of `abc::ROOT<int>::operator==(abc::ROOT<int> const&) const'
obj\src\B.o:B.cpp:(.text+0xfe): first defined here
etc...

J'ai cherché un peu du coté de GCC:
http://gcc.gnu.org/onlinedocs/gcc/Te...antiation.html

où l'on me parle de l'option -frepo, mais après essais, ça semble ne rien donner..

Avant de poursuivre dans une mauvaise direction, je sollicite vos avis. Mon architecture est-elle compilable ? Devrais-je faire autrement ? Comment ?

Je précise que j'ai plus l'habitude d'utiliser le polymorphisme classique que les templates, et qu'il y a peut-être quelque chose qui m'a échappé.

Merci pour vos réponses.

[koala01]

Salut,

Il suffit, en gros, de lire ce que te dit le compilateur

En l'occurence, il te dit qu'il y a plusieurs définitions pour l'opérateur == de ta classe ROOT.

Le plus souvent, c'est du au fait que la fonction au sujet de laquelle le compilateur se plaint d'une définition multiple n'est pas déclarée (de manière implicite ou explicite) inline.

Il faudrait donc voir le code de ta classe ROOT et, plus particulièrement, de son opérateur ==, mais la solution consiste soit à placer l'implémentation du dit opérateur directement dans la classe, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
template <typename T>
class ROOT
{
    public:
        bool operator==(ROOT const & r) const
        {
            /* ce qu'il faut faire */
        }
        /* le reste */
};

soit veiller à déclarer explicitement l'opérateur == comme étant inline, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
class ROOT
{
    public:
        bool operator==(ROOT const & r) const;
        /* le reste */
};
template <typename T>
inline bool ROOT<T>::operator == (ROOT<T> const & r) const
{
    /* ce qu'il faut faire */
}

[akirira]

Bon, merci beaucoup, c'était effectivement très bète, je n'avais pas mis les 'inline' devant les définitions dans le fichier de définition (qui lui était bien inclus dans le header)...

Je ne sais pas pourquoi (alors que je le fais bien pour les classes "normales"), je pensais que pour les template, il était facultatif !

Il suffit, en gros, de lire ce que te dit le compilateur
En l'occurence, il te dit qu'il y a plusieurs définitions pour l'opérateur == de ta classe ROOT.

Ce qui est piégant en fait, c'est que en l'absence du 'inline', il n'y a pas d'erreur, tant qu'il n'y a qu'une seule classe qui herite du template! C''est pour ça que je compilais correctement avant, et c'est quand j'ai ajouté la deuxième que l'erreur est apparue.
Bon, en même temps, c'est logique, un seul héritage=>pas de code en double=>pas d'erreur...