Perché l'operatore di assegnazione dovrebbe restituire un riferimento all'oggetto?

Question

Sto eseguendo alcune revisioni del mio C++ e ho a che fare con il sovraccarico dell'operatore al minuto, in particolare con l'operatore "=" (assegnazione). Stavo cercando online e ho incontrato più argomenti per discuterne. Nei miei appunti, ho tutti i miei esempi presi in giù come qualcosa di simile a

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

In tutti i riferimenti che ho trovato on-line, ho notato che l'operatore restituisce un riferimento all'oggetto di origine. Perché è il modo corretto per restituire un riferimento all'oggetto in contrasto con il nulla?

Answer 1

Il solito modulo restituisce un riferimento all'oggetto di destinazione per consentire il concatenamento di assegnazione. In caso contrario, non sarebbe possibile fare:

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

Eppure, tenere a mente che ottenere proprio l'operatore assigment is tougher than it might seem.

Answer 2

tipo Il ritorno non importa se si sta solo eseguendo un singolo incarico in una dichiarazione come questa:

x = y; 

Si inizia alla materia, quando si esegue questa operazione:

if ((x = y)) { 

. .. e conta davvero quando si esegue questa operazione:

x = y = z; 

Ecco perché si restituisce l'oggetto corrente: a tutti ow chaining assegnazioni con l'associatività corretta. È una buona pratica generale.

Answer 3

vostro operatore di assegnazione dovrebbe sempre fare queste tre cose:

1. Prendere un ingresso const riferimento (const MyClass &rhs) come il lato destro della cessione. La ragione di ciò dovrebbe essere ovvia, dal momento che non vogliamo modificare accidentalmente quel valore; vogliamo solo cambiare ciò che è sul lato sinistro.

2. Restituire sempre un riferimento al lato sinistro appena modificato, return *this. Questo per consentire il concatenamento dell'operatore, ad es. a = b = c;.

3. Controllare sempre l'assegnazione automatica (this == &rhs). Questo è particolarmente importante quando la tua classe fa la propria allocazione di 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 
   }