pb: polymorphisme, signature, comparaison d'objets

Bonjour,

Je souhaite comparer des objets de classes différentes (mais
appartenant tous à une hiérarchie commune) en parcourant un conteneur
qui voit les objets comme des pointeurs sur la base.
-- Si 2 objets à comparer sont de la même classe, alors la comparaison
doit prendre en compte les attributs spécifiques pour affiner la
comparaison.
-- La classe de base et le conteneur ne doivent pas avoir connaissance
des classes dérivées.
-- les classes dérivées doivent restées indépendantes entre elles.

Je voudrais utiliser un appel par virtualité pour toucher la méthode
C::Compare(const C& ref) définie dans chaque classe, mais comme les
signatures diffèrent, il n'y a pas de surcharge et donc ça appelle
toujours la méthode au niveau de la base. Si je surcharge correctement
(cf. classe D2 du code ci-dessous), je n'ai alors plus accès aux
données spécifiques pour l'objet passé en argument.

Quelqu'un aurait-il une solution élégante?

J'imagine ce problème classique: tri d'un std::list<T*> avec codage
d'un foncteur de comparaison, mais je bute dans mes recherches.

ci-dessous un bout de code qui présente le problème:
//<code>
#include <cstdio>
#include <cstdlib>

class Base
{
int m_Base;
public:
Base()
: m_Base(0)
{
}
virtual void Compare(const Base & ref) const
{
printf("Base m_Base %d %d", m_Base, ref.m_Base);
}
};

class D1 : public Base
{
int m_D1;
public:
D1()
: Base(),
m_D1(1)
{
}

virtual void Compare(const D1 & ref) const
{
Base::Compare(ref);
printf("D1 m_D1 %d %d", m_D1, ref.m_D1);
}
};

class D2 : public Base
{
int m_D2;
public:
D2()
: Base(),
m_D2(2)
{
}
virtual void Compare(const D2 & ref) const
{
Base::Compare(ref);
printf("D2 m_D2 %d %d", m_D2, ref.m_D2);
}
virtual void Compare(const Base & ref) const
{
// ref etant de Base, je ne peux pas utilise ref.m_D2
printf("D2 surcharge Base::Compare ref.m_D2 non utilisable
");
}
};

int main(void)
{
Base base_1, base_2;
D1 d1_1, d1_2;
D2 d2_1, d2_2;

Base* a_1[] = { &base_1, &d1_1, &d2_1 };
Base* a_2[] = { &base_2, &d1_2, &d2_2 };

int nbElt_1= sizeof(a_1)/sizeof(Base*);
int nbElt_2= sizeof(a_2)/sizeof(Base*);

for (int iE=0; iE<nbElt_1; iE++)
{
for (int yE=0; yE<nbElt_2; yE++)
{
printf("%d,%d:", iE, yE);
a_1[iE]->Compare( (*a_2[yE]) );
}
}

return EXIT_SUCCESS;
}

// resultat
0,0:Base m_Base 0 0 // Base vs Base
0,1:Base m_Base 0 0 // Base vs D1
0,2:Base m_Base 0 0 // Base vs D2
1,0:Base m_Base 0 0 // D1 vs Base
1,1:Base m_Base 0 0 // D1 vs DI NOK, je voudrais un
appel à D1::Compare
1,2:Base m_Base 0 0 // D1 vs D2 OK
D2 surcharge Base::Compare ref.m_D2 non utilisable // D2 vs Base
D2 surcharge Base::Compare ref.m_D2 non utilisable // D2 vs D1
D2 surcharge Base::Compare ref.m_D2 non utilisable // D2 vs D2

//</code>