¿Existe un enfoque idiomático en C++ para comparar tipos polimórficos para la equivalencia de objetos?

Question

Tengo punteros Base * para dos instancias de tipo polimórfico y necesito determinar si los objetos a los que se hace referencia son equivalentes.

Mi enfoque actual es utilizar por primera vez RTTI para verificar la igualdad de tipos. Si los tipos son iguales, entonces llamo a una función virtual is_equivalent.

¿Hay un enfoque más idiomático?

Answer 1

Para la mayoría de las clases derivadas, lo que equivale simplemente significa que las variables miembro todos el mismo valor

En C++ esto se llama 'igualdad' y por lo general se implementa utilizando operator==(). En C++ se puede anular el significado de los operadores, es posible escribir:

MyType A; 
MyType B; 
if (A == B) { 
    // do stuff 
} 

Y tienen == llamada a una función personalizada que defina.

Creo que desea diferenciar la igualdad de la identidad que significaría el mismo objeto (es decir, la misma dirección).

que se pueden implementar como función miembro o función libre (de Wikipedia):

bool T::operator ==(const T& b) const; 
bool operator ==(const T& a, const T& b); 

En su caso se desea implementar operator== de la clase base, y luego realizar lo que está haciendo.

Más concretamente sería el siguiente aspecto:

class MyBase 
{ 
    virtual ~MyBase(); // reminder on virtual destructor for RTTI 
    // ... 
private: 
    virtual bool is_equal(const MyBase& other); 

    friend bool operator ==(const MyBase& a, const MyBase& b); 

    // ...  
}; 

bool operator ==(const MyBase& a, const MyBase& b) 
{ 
    // RTTI check 
    if (typeid(a) != typeid(b)) 
     return false; 
    // Invoke is_equal on derived types 
    return a.is_equal(b); 
} 


class D1 : MyBase 
{ 
    virtual bool is_equal(const Base& other) 
    { 
     const D1& other_derived = dynamic_cast<const D1&>(other); 
     // Now compare *this to other_derived 
    } 
}; 

class D2 : MyBase; 
{ }; 


D1 d1; D2 d2; 
bool equal = d1 == d2; // will call your operator and return false since 
         // RTTI will say the types are different