Pourquoi l'opérateur d'affectation doit-il renvoyer une référence à l'objet?

Je suis en train de faire une révision de mon C++, et je fais face à la surcharge d'opérateur à la minute, plus précisément le "="(affectation) de l'opérateur. J'étais à la recherche en ligne et est venu à travers de multiples sujets de discussion. Dans mes notes, j'ai tous mes exemples pris comme quelque chose comme

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

Dans toutes les références que j'ai trouvé en ligne, j'ai remarqué que l'opérateur renvoie une référence à l'objet source.
Pourquoi est-ce la bonne façon de retourner une référence à l'objet, par opposition à la rien du tout?

source d'informationauteur maccard

  1. 17

    La forme habituelle renvoie une référence à l'objet cible pour permettre l'attribution de chaînage. Sinon, il ne serait pas possible de le faire:

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

    Encore, gardez à l'esprit que l'obtention de droit de l'affectation de l'opérateur est plus difficile qu'il ne paraît.

  2. 13

    Le type de retour n'a pas d'importance quand vous êtes juste à l'exécution d'une affectation unique dans une déclaration comme ceci:

    x = y;

    Il commence à compter lorsque vous faites cela:

    if ((x = y)) {

    ... et vraiment des questions quand vous faites cela:

    x = y = z;

    C'est pourquoi vous revenez à l'objet courant: pour permettre le chaînage des affectations de le corriger l'associativité. C'est une bonne pratique générale.

  3. 8

    Votre opérateur d'affectation doit toujours faire ces trois choses:

    1. Prendre un const-entrée de référence (const MyClass &rhs) que le côté droit de la cession. La raison de ce qui devrait être évident, puisque nous ne voulons pas accidentellement changement de cette valeur; nous ne voulons changer ce qui est sur le côté gauche.

    2. Toujours retourner une référence à la nouvelle altération de la gauche, return *this. C'est pour permettre à l'opérateur de chaîne, par exemple a = b = c;.

    3. Toujours vérifier pour l'auto-attribution de (this == &rhs). Ceci est particulièrement important si votre classe ne comprend sa propre allocation de la mémoire.

      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
}