Discussion :

[Opérateur]

Bonjour,

J'ai encore une question à propos de mes opérateurs surchargés :

Si je cherche à surcharger + dans une de mes classes, après avoir correctement surchargé +=, j'ai fait ceci :

Code :

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

1
2
3
4
5
6
template <typename Elem>
PolyD<Elem>& PolyD<Elem>:: operator + (PolyD V)
{ 
V += (*this); 
return V;
}

Ce qui fonctionne mais réflexion faite ça devrait planter royalement, vu que je renvois par référence un objet de portée locale, non ?
Je vais devenir fou avec ces opérateurs partout ...

merci

[koala01]

Effectivement, tu renvoie une référence vers quelque chose qui sera détruit au moment de quitter la fonction...

Ceci dit, assez bizarement, (en fait non: de manière très logique, si on suit la norme), si tu récupère la valeur de retour sous la forme d'une référence constante, cela fonctionnera sans problème, car une référence constante permet la construction d'un objet (qui deviendra temporaire pour la fonction dans laquelle tu récupère cette valeur)

A ce sujet, je te proposerais bien la lecture (en anglais) de cet article

Ceci dit, l'opérateur += peut renvoyer une référence parce qu'il renvoie... l'objet modifié, alors que l'opérateur + seul renvoie normalement... un nouvel objet, qui n'est donc ni l'opérande de gauche (l'objet en "cours") ni celui de droite (qui est donné en paramètre), il ne devrait donc pas renvoyer une référence

Ce qu'il faudrait normalement faire, c'est:

1. créer une variable du type ad-hoc qui soit la copie de l'objet en cours (*this)
2. utiliser (éventuellement) l'opérateur += sur cette variable en donnant comme opérande de droite l'objet passé en argument
3. renvoyer cette variable

Sur une classe MaClasse, l'opérateur se présenterait donc sous la forme de

Code :

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

1
2
3
4
5
6
MaClasse MaClasse::operator+(const MaClasse& op) const
{
    MaClasse temp= *this;
    temp+=op;
    return temp;
}

Nota: il n'est pas impossible que l'idiome copy and swap te vienne en aide pour une partie du travail

[white_tentacle]

Ceci dit, assez bizarement, (en fait non: de manière très logique, si on suit la norme), si tu récupère la valeur de retour sous la forme d'une référence constante, cela fonctionnera sans problème, car une référence constante permet la construction d'un objet (qui deviendra temporaire pour la fonction dans laquelle tu récupère cette valeur)

On a eu cette discussion récemment avec un ami, et j'avoue que je veux bien une clarification là-dessus. Le code suivant est valide de manière incontestable :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
A f() 
{ 
  A a; 
  return a; 
}
 
int main()
{
  const A& localA = f();
  ...
}

Par contre, le code suivant fait planter gcc à l'utilisation de localA

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
const A& f() 
{ 
  A a; 
  return a; 
}
 
int main()
{
  const A& localA = f();
  ...
}

En fait, le problème qu'on voit, c'est que autant, dans le cas de la valeur de retour, le compilateur sait statiquement où elle est allouée, et peut donc sans problème augmenter sa durée de vie, autant, dans le cas d'un renvoi de référence d'un objet alloué sur la pile en train d'être détruite, ce ne peut être fait que dynamiquement. Mais pourtant, ne pas le faire rompt le fait que la durée de vie d'un objet est étendu à celle de la référence constante...

Donc, bug de gcc ou incompréhension de la norme de ma part ?