Qual é o caminho certo para sobrecarregar o operador == para uma hierarquia de classes?
Suponha que eu tenha a seguinte hierarquia de classes:
class A
{
int foo;
virtual ~A() = 0;
};
A::~A() {}
class B : public A
{
int bar;
};
class C : public A
{
int baz;
};
Qual é o caminho certo para sobrecarregaroperator==
para essas classes? Se eu fizer todas as funções livres, então B e C não podem aproveitar a versão de A sem lançar. Isso também impediria que alguém fizesse uma comparação profunda tendo apenas referências a A. Se eu fizer as funções de membro virtual, uma versão derivada poderia se parecer com isso:
bool B::operator==(const A& rhs) const
{
const B* ptr = dynamic_cast<const B*>(&rhs);
if (ptr != 0) {
return (bar == ptr->bar) && (A::operator==(*this, rhs));
}
else {
return false;
}
}
Mais uma vez, eu ainda tenho que lançar (e parece errado). Existe uma maneira preferida de fazer isso?
Atualizar:
Existem apenas duas respostas até agora, mas parece que o caminho certo é análogo ao operador de atribuição:
Faça abstrações de classes não-folhaProtected não virtual nas classes não-folhaPúblico não virtual nas classes de folhaQualquer tentativa do usuário de comparar dois objetos de tipos diferentes não será compilada porque a função de base é protegida e as classes de folha podem aproveitar a versão do pai para comparar essa parte dos dados.