C++ -- Comment surcharger l'opérateur+= ?

Question

Étant donné l'extrait de code suivant,

class Num
{
public:
    Num(int iNumber = 0) : m_iNumber(iNumber) {}

    Num operator+=(const Num& rhs)
    {
        this->m_iNumber = (this->m_iNumber + rhs.m_iNumber);
        return *this;
    }
private:
    int m_iNumber;
};

//===========================================================
int _tmain(int argc, _TCHAR* argv[])
{
    Num a(10);

    Num b(100);

    b += a;

    return 0;
}

J'aimerais savoir comment surcharger correctement la fonction operator+= .

Questions :

1. Comment définir la signature de cet opérateur ? En particulier, que doit-on utiliser pour la valeur de retour ?

2. Comment mettre en œuvre le corps de la fonction ?

3. Comment utiliser cet opérateur de surcharge ?

J'ai fourni une solution comme ci-dessus mais je crains qu'elle ne soit pas correcte.

Answer 1

Retour par référence serait mieux

Num& operator+=(const Num& rhs){

      this->m_iNumber += rhs.m_iNumber;
      return *this;
}

Answer 2

Si vous suivez pour ce Wikibook vous trouverez ces réponses par l'exemple :

1. Type& operator+=(const Type& right) est la signature correcte.
2. Tu l'as bien fait.
3. Vous utilisez un opérateur surchargé comme les opérateurs ordinaires, mais avec votre type à la place. C'est un peu le but de l'exercice ;)

Notez que les opérateurs d'affectation composés doivent être des fonctions membres.

Answer 3

La signature de l'un des opérateurs d'affectation (opérateur= ou opérateur @= pour votre opérateur préféré @) doit être la suivante

Class& operator @= (const Class& rhs);

C'est-à-dire que la fonction prend son paramètre par référence constante (car elle ne le modifie pas), puis renvoie une référence mutable à l'objet. La raison pour laquelle vous retournez une référence non-const est que, pour des raisons historiques, vous pouvez écrire du code comme celui-ci :

(a += b) += c;

Ce n'est en aucun cas un bon style, mais il fonctionne pour les ints et vous devriez donc vous efforcer de le faire fonctionner pour vos types également.

En ce qui concerne le corps de votre fonction, ce que vous avez là est parfaitement correct. En général, cependant, vous devez être sûr que le code fonctionne même si le paramètre est l'objet récepteur. Par exemple, si vous écrivez quelque chose comme

a += a;

Cela se traduit par

a.operator+= (a);

Et ainsi le code fonctionnera avec le paramètre et le récepteur étant le même objet. Ce problème ne se pose généralement pas pour les opérateurs d'affectation composés (en général, seuls les opérateurs de type operator= doit s'en préoccuper), mais dans certains cas, vous pouvez vous brûler si vous ne faites pas attention.

Enfin, vous pouvez utiliser ce operator += comme vous l'avez fait dans l'exemple de code ci-dessus. Toute utilisation de += l'appelle automatiquement.

J'espère que cela vous aidera !

Answer 4

Votre exemple est tout à fait correct : http://codepad.org/PVhQw9sc .

1. Vous pouvez définir la valeur de retour comme étant ce que vous voulez. Si vous voulez qu'elle corresponde à ce que int le fait, il devrait retourner le type Num& et retourne la valeur *this .
2. Vous l'avez fait correctement.
3. Vous l'avez également fait correctement.

Answer 5

Écrivez le corps comme vous l'avez fait. Utilisez l'opérateur comme vous l'avez fait. L'opérateur doit retourner une référence pour permettre le chaînage.

Ver ici .