pb: polymorphisme, signature, comparaison d'objets

Bonjour,

Je souhaite comparer des objets de classes diff=E9rentes (mais
appartenant tous =E0 une hi=E9rarchie commune) en parcourant un conteneur
qui voit les objets comme des pointeurs sur la base.
-- Si 2 objets =E0 comparer sont de la m=EAme classe, alors la comparaison
doit prendre en compte les attributs sp=E9cifiques pour affiner la
comparaison.
-- La classe de base et le conteneur ne doivent pas avoir connaissance
des classes d=E9riv=E9es.
-- les classes d=E9riv=E9es doivent rest=E9es ind=E9pendantes entre elles.

Je voudrais utiliser un appel par virtualit=E9 pour toucher la m=E9thode
C::Compare(const C& ref) d=E9finie dans chaque classe, mais comme les
signatures diff=E8rent, il n'y a pas de surcharge et donc =E7a appelle
toujours la m=E9thode au niveau de la base. Si je surcharge correctement
(cf. classe D2 du code ci-dessous), je n'ai alors plus acc=E8s aux
donn=E9es sp=E9cifiques pour l'objet pass=E9 en argument.

Quelqu'un aurait-il une solution =E9l=E9gante?

J'imagine ce probl=E8me 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=E9sente le probl=E8me:
//<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\n", 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\n", 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\n", 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
\n");
}
};

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

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

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

for (int iE=3D0; iE<nbElt_1; iE++)
{
for (int yE=3D0; 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 =E0 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>