Discussion :

[runn2]

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 :

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

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 :

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

1
2
3
4
5
class B
{
     public :
        int titi;
}

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

Code :

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

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]

[Laurent Gomila]

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 :

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

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 :

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

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.

[JolyLoic]

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 :

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

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 :

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

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

[jmv]

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 :

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

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 :

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

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; }
}

[runn2]

Salut,

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

Merci pour l'aide

[Laurent Gomila]

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

[jmv]

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 :

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

1
2
3
4
5
template <typename T>
bool operator>(const T& left, const T& right)
{
    return right < left;
}