Opérateurs : * et *=

Bonjour,

Il semble qu'il soit commun d'implémenter l'opérateur binaire * en faisant appel à l'opérateur unaire *=.

Pourquoi pas l'inverse ?

Bonjour,
Parce que c'est plus efficace, non ?
Naivement je dirais que si l'on implémente *= grâce à * alors le code ressemblera plus ou moins à ça :

Code:

---

1 2 3 4 5

class T { int privatestuff; //... };

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11

T T::operator*(const T& t1, const T& t2) { T t; // un temporaire t.privatestuff = t1.privatestuff * t2.privatestuff; return t; } T& T::operator*=(const T& t) { *this = (*this) * t; // création d'un temporaire + assignation return *this; }

---

Alors que dans le sens habituel, * implémenté grâce à *=

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

T& T::operator*=(const T& t) { this->privatestuff *= t.privatestuff; // une multiplication return *this; }   // fonction libre T operator*(const T& t1, const T& t2) { T t = t1; t *= t2; return t; }

---

En résumé dans le premier cas, l'op* et l'op*= vont tous les deux créer des temporaires/faire des copies alors que dans le cas 2 seul l'op* crée un temporaire.
(il faut tempérer par le fait que le compilateur va peut être optimiser les choses, mais autant ne pas pessimiser le code et partir directement sur la version la plus efficace)

NB: il y a des cas où pour la multiplication on va écrire =* en fonction * : quand on ne peut pas altérer une partie de la valeur de *this sans empêcher le calcul d'autres parties.
Cas typiques : multiplication de matrices ou de polynômes.

Citation:

---

Envoyé par Luc Hermitte

NB: il y a des cas où pour la multiplication on va écrire =* en fonction * : quand on ne peut pas altérer une partie de la valeur de *this sans empêcher le calcul d'autres parties.
Cas typiques : multiplication de matrices ou de polynômes.

---

C'est justement mon cas. :)

En revanche, je ne comprend pas bien l'explication que tu donnes.

M et N, matrices 2x2
M0, source, M1 resultat

M1(0,0) <- M0(0,0) * N(0,0) + M0(0,1)*N(1,0)
M1(0,1) <- M0(0,0) * N(0,1) + M0(0,1)*N(1,1)

Dans le cas de =*, M0 et M1 c'est la même chose. De fait le second calcul utiliserait une variable qui a été altérée lors du premier calcul. Pas bon.
Il faut passer par un temporaire. Et pour ça, l'opérateur binaire conviendrait très bien.

OK, merci !