J'ai surchargé l'opérateur + comme ceci
class sample
{
private :
int x;
public :
sample(int x1 =0)
{
x = x1;
}
sample operator+(sample s);
};
sample sample::operator+(sample s)
{
x = x + s.x;
return *this;
}
int main()
{
sample s1(10);
sample s2;
s2 = s2 + s1;
return 0;
}
Est-ce correct? Ma question est la suivante: si je veux ajouter deux exemples d'objets différents, comment vais-je surcharger l'opeartor; par exemple pour s = s1 + s2
;
J'ai envie de faire s = s + s1 + s2
avec l'implémentation existante.
Utiliser la surcharge des opérateurs amis devrait faire l'affaire pour vous et est un moyen courant de définir des opérateurs binaires, ajoutez simplement:
friend sample operator+(const sample& a, const sample& b); //in class
sample operator+(const sample& a, const sample& b) { //outside the class
return sample(a.x + b.x);
}
Si vous voulez qu'il reste membre, (qui a des inconvénients dans certains scénarios rares et aucun avantage), vous devez faire de l'opérateur une fonction const
:
sample operator+(sample s) const; //in class
sample sample::operator+(const sample& b) const { //outside the class
return sample(this->x + b.x);
}
L'un ou l'autre permettra le chaînage des opérateurs. La raison pour laquelle votre précédent s = s + s1 + s2
échouait, c'est que le s + s1
exécuterait et retournerait un objet temporairesample
. Ensuite, il tentera d'ajouter s2
à cet échantillon. Cependant, les temporaires ne peuvent être que des références const
[1], et en tant que tel, ne peut utiliser que les fonctions membres const
. Depuis votre operator+
La fonction membre n'est pas une fonction const
, vous ne pouvez pas utiliser cette fonction sur le const
temporaire. Notez que pour le rendre const
, j'ai dû le réécrire, car votre version modifie l'objet sur le côté gauche du +
.
[1] avec des exceptions ne sont pas particulièrement pertinentes ici, à savoir rvalues