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 folha

Qualquer 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.