Supongamos que tengo la siguiente jerarquía de clases:

class A
{
    int foo;
    virtual ~A() = 0;
};

A::~A() {}

class B : public A
{
    int bar;
};

class C : public A
{
    int baz;
};

¿Cuál es la forma correcta de sobrecargaroperator== para estas clases? Si hago todas las funciones gratuitas, B y C no pueden aprovechar la versión de A sin lanzar. También evitaría que alguien realice una comparación profunda con solo referencias a A. Si les hago funciones miembro virtuales, una versión derivada podría tener este aspecto:

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;
    }
}

Una vez más, todavía tengo que lanzar (y se siente mal). ¿Hay una forma preferida de hacer esto?

Actualizar:

Hasta el momento solo hay dos respuestas, pero parece que la forma correcta es análoga al operador de asignación:

Hacer clases abstractas sin hojas.Protegido no virtual en las clases no-hoja.Público no virtual en las clases hoja.

Cualquier intento de usuario de comparar dos objetos de diferentes tipos no se compilará porque la función base está protegida, y las clases de hoja pueden aprovechar la versión de los padres para comparar esa parte de los datos.