Perché l’operatore incaricato deve restituire un riferimento all’object?

Sto facendo una revisione del mio C ++, e mi sto occupando dell’overloading dell’operatore al minuto, in particolare dell’operatore “=” (assegnazione). Stavo cercando online e ho incontrato più argomenti per discuterne. Nelle mie note, ho tutti i miei esempi presi come qualcosa del genere

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 online, ho notato che l’operatore restituisce un riferimento all’object sorgente. Perché è il modo corretto per restituire un riferimento all’object in contrasto con il nulla?

Il solito modulo restituisce un riferimento all’object di destinazione per consentire il concatenamento di assegnazione. Altrimenti, non sarebbe ansible fare:

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

Tuttavia, tieni presente che ottenere l’operatore dell’assistenza è più difficile di quanto possa sembrare .

Il tipo di ritorno non ha importanza quando esegui un singolo compito in una dichiarazione come questa:

 x = y; 

Inizia a essere importante quando lo fai:

 if ((x = y)) { 

… e conta davvero quando lo fai:

 x = y = z; 

Ecco perché restituisci l’object corrente: per consentire assegnamenti concatenati con l’associatività corretta. È una buona pratica generale.

Il tuo operatore di assegnazione dovrebbe sempre fare queste tre cose:

  1. Prendi un input di riferimento (const MyClass &rhs) come il lato destro del compito. 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 a = b = c; .

  3. Controlla sempre l’auto assegnazione (this == &rhs) . Questo è particolarmente importante quando la tua class 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 }