Spécialisation template et fonctions inline

Bonjour à tous!

Je suis nouveau sur le forum, mais je programme en C++ depuis quelques temps déjà (3 ans). Dans le cadre d'un projet (niveau universitaire), j'ai "du" me mettre aux templates, chose que je n'avais jamais pratiquée avant. Plus précisément, je fais une classe de polynomes template.

Ma question est la suivante:
Lorsque je veux spécialiser une méthode de ma classe template (par exemple la division pour les double), le compilateur me dit que que j'ai des déclarations multiples des fonctions spécialisées. Le seul truc que j'ai trouvé pour que ca passe est de déclarer ces spécialisations "inline" ( du style  " template<> inline void Polynom<double>:: ..."). Mais de ce que je sais de "inline", c'est qu'il est mieux de l'utiliser sur des fonctions plutot courtes... et la ce n'est pas vraiment le cas. Y a-t-il moyen de faire mieux? Sinon pourquoi ce inline est-il nécessaire?

Merci pour vos réponses!

(Je mettrai les sources quand j'aurai fini de chasser les bugs  )

Tu devrais pas avoir besoin de inline. Mets voir ton code parce que ta syntaxe paraît correcte (même sans inline).

Voilà un bout du code:

// Definition de la classe
template <typename T>
class Polynom
{
   [...]

    // Simplification
    void simplify();

   [...]
};

// Definition des methodes
template <typename T>
void Polynom<T>::simplify()
{
      [...]    
};

template <>
inline void Polynom<double>::simplify()
{
         [...]
 };

Tout est dans le même fichier. (J'avais aussi oublié de préciser que je travaille avec Dev-C++ pour ce projet)

Merci!

P.S: la prochaine fois je mettrai dans le forum "débutant" , je l'avais pas vu!

Ca marche sans le "inline" ?

Voici mon main:

int main(int argc, char *argv[])
{
    Simulation polycristal;
    polycristal.init_display(argc, argv);
    polycristal.init_triangulation();
    polycristal.init_queue();
    system("PAUSE");
    glutMainLoop();
   
    system("PAUSE");
};

En fait, je viens de me rendre compte d'un détail auquel je n'avais pas fait attention: J'avais fait un projet de test pour mes polynomes, et celui-ci (toujours sous Dev-C++) marche convenablement sans les "inline" ! C'est par après que je les avais rajoutés...

C'est un "probleme" made in Dev-C++

Ce code est OK chez moi (doit compiler et retourner 16 (0x10 en hexa)) :

template

<class T>
class A{public:int B(void);};

template

<class T>
int A<T>::B(void) {return 0;}

template

<>
int A<double>::B(void){return 1;}

int

main(void)
{
A<double> aDouble;
A<int> aInt;
return aDouble.B()*0x10+aInt.B();
}

C'est ce que tu as fait en simplifié, si ca ne fonctionne pas chez toi je sais plus quoi dire.

Ca marche aussi est ca donne 16 !

Sinon, j'ai mis tout le code source en ligne.

Je te remercie en tout cas de ton aide!

Pour info, il me semble que l'instruction inline sera a dire au compilo de recopier systematiquement le code à chaque appel (au lieu de faire un call).
si le compilo est un tantinet intelligent il est capable de le faire seul.
(ou selon le model de compilation/optimisation que vous avez choisi)
mais bon... un call c env 30 cycles ...

sinon dans ton exemple
template <typename T>
class Polynom
{
    void simplify();
};

template <typename T>
void Polynom<T>::simplify()
{
      [...]    
};

pkoi ne pas faire directement
template <typename T>
class Polynom{
    void simplify() {// le code directement ici //};
};

???

FoxZ...

Exact, FoxZ, tout comme si le inline est "inutile", il n'en tient pas compte...