Héritage et Spécialisation Template

Bonjour a tous j'ai (encore) une question:

J'ai une classe ClovisVariable et plusieurs autre classe qui héritent de celle-ci : CString CFloat CInteger ...

J'ai crée une Class Node dont j'ai spécialisé une fonction. voici un bref résumé.

Code:

---

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

template <class T> Class Node{   public: Node(); void getPath();   }   template <class T> T * Node<T>::getPath(){ std::cout << "Type Inconnu" << std::endl; return NULL; }   Node<ClovisVariable> * Node<ClovisVariable>::getPath(CString name){ std::cout << "clovis variable" << std::endl; return NULL; }

---

Donc quand je fais ceci:

Code:

---

1 2 3

Node<CString> * j = new Node<CString>(); j->getPath();

---

Il m'affiche type inconnu alors que j'aimerai qu'il m'affiche Clovis Variable

Je ne sais pas quoi faire pour que quand je mets

Code:

---

1 2 3 4

Node<CString> * j = new Node<CString>(); Node<CInteger> * i = new Node<CInteger>(); Node<CFloat> * k = new Node<CFLoat>();

---

a chaque fois que je fais appel à la fonction getPath() il m'affiche Clovis Variable.

Quelqu'un peut il m'eclairer de ses lumières?

Si je me rappelle bien, ce n'est pas possible.
Avec les spécialisation c'est exactitude totale ou rien.

Je crois savoir que ce sujet à déjà été traité (cas très similaire). Il faut que je recherche pour confirmer.

Edit: 3 solutions :
-cast.C'est assez simple, mais c'est moche.

example :
(code fait par adema)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

#include <iostream>   class ClovisVariable { };   class CInteger : public ClovisVariable { };   class CString : public ClovisVariable { };   class CFloat : public ClovisVariable { };   template <class T> class Node { public: void getPath(T); };   template <class T> void Node<T>::getPath(T name) { std::cout << "Type Inconnu" << std::endl; }   template <> void Node<ClovisVariable>::getPath(ClovisVariable name) { std::cout << "clovis variable" << std::endl; }   typedef Node<ClovisVariable> NodeClovis;   int main(void) { CString i_string; Node<ClovisVariable> * i_node = new Node<ClovisVariable>(); i_node->getPath(static_cast<ClovisVariable>(i_string));   CInteger j_integer; Node<ClovisVariable> * j_node = new Node<ClovisVariable>(); j_node->getPath(static_cast<ClovisVariable>(j_integer));   CFloat k_float; Node<ClovisVariable> * k_node = new Node<ClovisVariable>(); k_node->getPath(static_cast<ClovisVariable>(k_float));   delete i_node; delete j_node delete k_node; return 0; }

---

Spécialisation "à la main"
Si le nombre de type est petit, on expliciter toutes les spécialisation.

Spécialisation "automatique"
La on sort la grosse artillerie: la métaprogrammation :D
Voici un code non testé qui résume mon idée:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

#include <iostream>   class ClovisVariable { };   class CInteger : public ClovisVariable { };   class CString : public ClovisVariable { };   class CFloat : public ClovisVariable { };   template <class H, class SousListe> struct ListeType {}; struct ListeFin {};   template <class T> class Node;   template <class H,class SousListe> class Node< ListeType<H, SousListe> > : public Node<SousListe> { public: H* getPath(const H& h) { std::cout << "Type Connu : Clovis" << std::endl; return NULL; } };   // Spécialisation pour le type de fin de liste // C'est la super-classe template <> class Node< ListeFin > { public:   template <class Z> Z* getPath(const Z& z) { std::cout << "Type Inconnu" << std::endl; return NULL; } };   typedef ListeType<ClovisVariable, ListeType<CInteger, ListeType<CFloat, ListeType<CString, ListeFin> > > > UneListeClasses;   int main() { int i; CString i_string; Node<UneListeClasses> * i_node = new Node<UneListeClasses>(); i_node->getPath(i_string);   CInteger j_integer; Node<UneListeClasses> * j_node = new Node<UneListeClasses>(); j_node->getPath(j_integer);   CFloat k_float; Node<UneListeClasses> * k_node = new Node<UneListeClasses>(); k_node->getPath(i);   delete i_node; delete j_node delete k_node;   return 0; }

---