Template abstrait et héritage
Bonjour,
Sur une plateforme ne diposant pas de la STL, je cherche à implémenter un mécanisme de gestion de listes doublement chaînée générique.
J'ai donc un template List. Celui-ci fonctionne.
Je souhaite maintenant créer une version ordonnée de ce template. Je cherche donc un moyen de créer une methode du template list qui insère de manière ordonnée.
La méthode (grosso-modo) :
Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| template < typename T >
class List
{
// ...
void insert (const T& elt, const Comparator< T >& compar)
{
ListCell* curElt = head;
while (curElt && compar(curElt, elt))
{
curElt = curElt->next;
}
// code d'insertion
}
// ...
}; |
Le principe est donc basé sur l'utilisation d'une class template abstraite Comparator dont voici la déclaration :
Code:
1 2 3 4 5 6 7
| template < typename T >
class Comparator
{
public:
virtual bool operator() (const T& p1, const T& p2) const = 0;
}; |
Pour choisir un ordre, je n'ai plus qu'à créer des classes concrètes héritant de la bonne implémentation du template abstrait Comparator :
Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| class TrueComparator : public Comparator< MyType* >
{
public:
inline virtual bool operator() (const MyType*& p1, const MyType*& p2) const
{
return true;
}
};
class FalseComparator : public Comparator< MyType* >
{
public:
inline virtual bool operator() (const MyType*& p1, const MyType*& p2) const
{
return false;
}
}; |
Cependant lorsque j'essaye d'utiliser ces classes, je fait (simplification encore) :
Code:
1 2 3 4
| List<MyType*> myListe;
MyType* myElement = new MyType;
FalseComparator myComparator;
myList.insert(myElement, myComparator); |
Mais le compilo visual (essayé sous gcc aussi) me dit que les classes TrueComparator et FalseComparator sont abstraites parce que je n'ai pas surchargé l'operateur "()" :cry:.
Je n'arrive pas à voir où se cache l'erreur, et il y a certainement quelqu'un ici qui a déjà fait un design de ce genre.
Une idée ?
Merci.
Floof