Discussion :

[oodini]

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 ?

[Arzar]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class T 
{
  int privatestuff;
  //...
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[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.

[oodini]

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.

[Luc Hermitte]

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.

[oodini]

OK, merci !