C++: implementando el método igual - ¿cómo asegurarse de que el objeto dado no sea la misma referencia que este?

Question

Considere el siguiente fragmento de código:

bool SomeObject::equal(const SomeObject& rhs) const 
{ 
    if (this == &rhs) 
    { 
    return true; 
    } 

    // check the state 
} 

El problema con este código es que SomeObject podría anular operator& (o alguien podría añadir en el futuro), que a su vez puede romper esta aplicación.

¿Es posible comprobar si rhs y *this son el mismo objeto sin estar a merced de la implementación operator&?

Answer 1

Si desea obtener la dirección real del objeto e ignorar sobrecargados & operadores a continuación, utilizar std::addressof

bool SomeObject::equal(const SomeObject& rhs) const 
{ 
    if (this == std::addressof(rhs)) 
    { 
    return true; 
    } 

    // check the state 
} 

Referencia: http://en.cppreference.com/w/cpp/memory/addressof

Answer 2

sólo tiene que pasar un puntero a someObject lugar de una referencia, por lo que ya no necesita el operador &.

que le gustaría esto, entonces:

bool SomeObject::equal(const SomeObject* rhs) const 
{ 
    if (this == rhs) 
    { 
     return true; 
    } 
    //... 
} 

Answer 3

¿Qué pasa si se acaba de quitar esa condición en su totalidad? ¿Con qué frecuencia alguien comparará un objeto consigo mismo? Si generalmente necesita inspeccionar todos los miembros de datos de todos modos, esta simple comparación solo desperdicia tiempo en el caso promedio. Mientras no ocurra nada malo cuando los dos objetos son físicamente iguales (y su función es const, entonces debería estar bien), entonces ¿cuál es el daño al hacer un poco de trabajo adicional en este raro caso?

Answer 4

Hay una función std::addressof en C++ 11 que debe hacer lo que desee.

Si quisiera aplicar usted mismo, usted podría utilizar la fundición a otro tipo:

(SomeClass*)&reinterpret_cast<char&>(rhs) 

Sin embargo, no me molestaría; una función const equals debería funcionar bien para parámetros idénticos.