pourquoi ne puis-je pas utiliser le type de référence dans l'opérateur= ?

Question

J'essaie de remplacer operator+ y operator= pour mes cours. Voici mon code :

#include <iostream>
#include <vector>

using namespace std;

class Integer {
public:
    int i;
    Integer operator+ (Integer&);
    Integer& operator= (Integer&);
};

Integer Integer::operator+(Integer& rhs) {
    Integer res;
    res.i = this->i + rhs.i;

    return res;
}

Integer& Integer::operator=(Integer& rhs) {

    this->i = rhs.i;
    return *this;
}

int main()
{
    Integer i1, i2, i3;
    i1.i = 1, i2.i = 2;
    i3 = i1 + i2;
    cout << i3.i;
}

Dans visual studio 2017, le compilateur s'est plaint que :

"E0349  no operator "=" matches these operands"

Il semble qu'un Integer ne correspond pas à l'objet Integer& dans le operator= fonction. Mais cela fonctionne pour operator+ fonction. C'est très déroutant.

Merci beaucoup.

Answer 1

i3 = i1 + i2;

renvoie une variable temporaire de type Integer .

Maintenant, votre operator= prend un Integer& . Il s'agit d'une référence à un Integer . Le problème est que les temporaires ne peuvent pas se lier à des références non-const.

Assurez-vous juste que vous changez pour const Integer& . C'est la valeur par défaut pour toutes les surcharges d'opérateurs de toute façon.

Answer 2

Je vais décomposer cela à partir de l'énoncé de la mission.

i3 = i1 + i2;

La première chose qui se passe est que l'expression d'addition est évaluée. C'est cet extrait de code :

i1 + i2

Vous avez conçu votre surcharge d'opérateur pour gérer cette expression. Votre surcharge d'opérateur d'addition personnalisée renvoie un nouveau Integer instance. Mais le problème survient lorsque vous essayez d'affecter cette nouvelle instance au paramètre dans votre surcharge d'affectation. Voici un extrait de ce code.

Integer& Integer::operator=(Integer& rhs);

Lorsque vous utilisez un paramètre référencé dans une déclaration de fonction, le compilateur vérifie que cette valeur n'est pas une valeur temporaire, afin qu'elle existe après l'appel de la fonction. Le compilateur a déterminé (correctement) que l'argument passé à cette instruction d'affectation est une valeur temporaire. C'est pourquoi il émet une erreur lorsque vous essayez de faire cela.

La raison la plus logique que je vois de rendre votre code être sensé est de mettre en œuvre ce qui suit :

Integer& Integer::operator=(const Integer& rhs) {
    this->i = rhs.i;
    return *this;
}

En ajoutant le spécificateur const, vous indiquez au compilateur que vous ne vous fiez pas à l'option rhs pour persister après l'appel de la fonction. Dans ce cas, la valeur passée en paramètre peut être une valeur temporaire.