Class Template : variable membre de nom inconnu a priori ?

Salut,

Je cherche le moyen de faire une classe template ou je pourrai préciser le nom d'une variable de la classe qui servira de critère de trie uniquement lors de l'instanciation du template.

Je m'explique par un exemple très simple :

J'ai la classe A, qui est une classe ordinaire, elle comporte une variable membre nommé "toto", donc :

Code:

---

1 2 3 4 5

class A { public : int toto; }

---

J'ai la classe B, qui est une classe ordinaire aussi, elle comporte une variable membre nommé "titi", donc :

Code:

---

1 2 3 4 5

class B { public : int titi; }

---

J'ai une autre classe Tem, qui est une classe template:

Code:

---

1 2 3 4 5 6

template <class T>class Tem { public: FaitTrie(); .... }

---

Je voudrai que quand je crée un template en remplacant "T" par A, la méthode "FaitTrie" tienne compte de la variable "toto", mais quand je fais le template pour B, la même méthode tienne compte de "titi".

Cela vous semble t 'il possible ? Ou est ce un cas impossible à faire en C++ (en Visual C++) ?

Merci d'avance pour vos avis ou solutions


[Balises CODE rajoutées par Loulou24, meci d'y penser à l'avenir]

Je pense que le mieux serait de spécifier un foncteur pour chaque classe (ou mieux si tu peux : l'opérateur <). Le tout étant d'avoir le même nom dans chaque classe qui sera paramètre template.

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

class A { public :   int titi; struct Sort { bool operator()(const A& a1, const A& a2) const {return a1.titi < a2.titi;} }; };   class B { public :   int toto; struct Sort { bool operator()(const B& b1, const B& b2) const {return b1.toto < b2.toto;} }; };   template <class T> class Tem { public :   void FaitTrie() { // Utilise T::Sort pour trier les éléments // ou T::operator <() si tu peux le définir pour chaque classe } .... };

---

Une autre variante : tu peux aussi faire une structure Sort globale qui soit template, et la spécialiser pour chaque classe (A, B, ...). Ta classe Tem utilisera alors Sort<T>::operator() (ou une autre fonction / opérateur, peu importe).

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template <class T> struct Sort {};   template <> struct Sort<A> { bool operator ()(const A& a1, const A& a2) const {return a1.titi < a2.titi;} };   template <> struct Sort<B> { bool operator ()(const B& b1, const B& b2) const {return b1.toto < b2.toto;} };

---

L'inconvénient ici est que Sort<T> devra sûrement être ami de T.

Si tu n'as pas accès aux classes A et B (ou si tu considère ques ces infos de tri n'en font pas conceptuellement partie), tu peux aussi utiliser une classe de traits :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<class T> Tem_traits { static bool compare(T const &t1, T const &t2) {return t1<t2;} };   template<> Tem_traits<A> { static bool compare()(A const &a1, A const &a2) {return a1.toto < a2.toto;} };   // Idem pour B

---

Et dans FaitTrie, tu utilises simplement :

Code:

---

Tem_traits<T>::compare (t1, t2);

---

Salut
Ton pb est classique losque l'on veux utiliser toute la puissance de la STL sur ses propres classes, pour pouvoir faire du tri, il faut definir les opérateur == et <

Code:

---

1 2 3 4 5 6 7

class A { public : int toto; bool operator==(const A& a) { return toto==a.toto; } bool operator<(const A& a) { return toto<a.toto; } }

---

Code:

---

1 2 3 4 5 6 7

class B { public : int titi; bool operator==(const B& b) { return titi==b.titi; } bool operator<(const B& b) { return titi<b.titi; } }

---

Salut,

Effectivement définir les opérateurs résoud mon problème.

Merci pour l'aide

Seul l'opérateur < est requis (pour ce qui est de la STL en tout cas). Tous les autres peuvent s'en déduire.

Citation:

---

Envoyé par Loulou24

Seul l'opérateur < est requis (pour ce qui est de la STL en tout cas). Tous les autres peuvent s'en déduire.

---

Oui, pour faire du trie avec la STL on a besoin que le l'opérateur <.
Pour les autres opérateus il existe des fonctions templates dans <utility> (fichier à inclure).
L'opérateur != est construit à partir de ==
Les opérateurs >, <=, >= sont construits à partir de <

exemple :

Code:

---

1 2 3 4 5

template <typename T> bool operator>(const T& left, const T& right) { return right < left; }

---