¿Por qué debería el operador de asignación devolver una referencia al objeto?

Question

Estoy haciendo una revisión de mi C++, y estoy lidiando con la sobrecarga del operador en el minuto, específicamente el operador "=" (asignación). Estaba buscando en línea y encontré varios temas discutiéndolo. En mis propias notas, tengo todos mis ejemplos tomados abajo como algo parecido a

class Foo 
{ 
    public: 
     int x; 
     int y; 
     void operator=(const Foo&); 
}; 
void Foo::operator=(const Foo &rhs) 
{ 
    x = rhs.x; 
    y = rhs.y; 
} 

en todas las referencias que encontré en línea, me di cuenta de que el operador devuelve una referencia al objeto de origen. ¿Por qué es la forma correcta de devolver una referencia al objeto en lugar de la nada en absoluto?

Answer 1

La forma habitual devuelve una referencia al objeto de destino para permitir el encadenamiento de asignación. De lo contrario, no sería posible hacerlo:

Foo a, b, c; 
// ... 
a = b = c; 

Sin embargo, tenga en cuenta que acertar el operador assigment is tougher than it might seem.

Answer 2

tipo El retorno no importa cuando estás realizando una sola asignación en una declaración como esta:

x = y; 

Se comienza a adquirir importancia cuando se hace esto:

if ((x = y)) { 

. .. y realmente importa cuando haces esto:

x = y = z; 

Es por eso que devuelves el objeto actual: a todos encadenando asignaciones con la asociatividad correcta. Es una buena práctica general.

Answer 3

Su operador de asignación siempre debe hacer estas tres cosas:

1. Tome una entrada const referencia (const MyClass &rhs) como el lado derecho de la asignación. La razón para esto debería ser obvia, ya que no queremos cambiar accidentalmente ese valor; solo queremos cambiar lo que está en el lado izquierdo.

2. Siempre devuelva una referencia al lado izquierdo nuevamente alterado, return *this. Esto es para permitir el encadenamiento del operador, p. a = b = c;.

3. Compruebe siempre la auto asignación (this == &rhs). Esto es especialmente importante cuando su clase hace su propia asignación de memoria.

   MyClass& MyClass::operator=(const MyClass &rhs) { 
       // Check for self-assignment! 
       if (this == &rhs) // Same object? 
        return *this; // Yes, so skip assignment, and just return *this. 
   
       ... // Deallocate, allocate new space, copy values, etc... 
   
       return *this; //Return self 
   }