Surcharge d'operator ..

Version imprimable

Bonjour à tous

J'ai un exercice à faire en cours de C++ sur la surcharge des opérateur. Nous devons créer une classe Rationel ou Fraction et surcharger les opérateurs adéquates pour simplifier l'utilisation de la classe. J'ai donc créé une classe Fraction toute bête
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Fraction { private: int num; int den; public: Fraction& operator=(const Fraction &); Fraction operator+(const Fraction &) friend operator+(const int &, const Fraction &); }
Voila la définition des mes fonctions operator
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 Fraction& Fraction::operator=(const Fraction &frac) { denominateur = frac.denominateur; numerateur = frac.numerateur; return *this; } Fraction Fraction::operator+(const Fraction &frac) { Fraction fr; fr.num = (num * frac.den) + (frac.num * den); fr.den = den * frac.den; return fr; } Fraction operator+(const int &entier, const Fraction &frac) { Fraction fr; fr.numerateur = frac.numerateur + entier * frac.denominateur; fr.denominateur = frac.denominateur; return fr; }
J'ai créé une fonction amie operator+ parce que je n'étais pas capable avec une fonction operator+ membre de la classe d'écrire un truc du style

F1 = 1 + F2;

Alors que je pouvais écrire F1 = F2 + 1;

Et visiblement ma fonction amie fonctionne pour les deux cas de figure

F1 + 1 ou 1 + F1

Est ce c'est normal ? J'avais pensé au début qu'il fallait laisser la fonction membre pour le cas F1 + 1 et la fonction amie pour l'autre cas, et lorsque j'ai supprimé la fonction membre operator+ o surprise cela fonctionnait très bien aussi.

30/05/2013, 13h33
haraelendil

oui c'est normal, il ne faut définir ton opérateur qu'une fois, soit par une fonction membre, soit par une fonction libre, ça ne sert à rien de faire les deux.
Généralement, on préfère les définir en tant que fonction libre précisément pour le cas que tu montre ici, ça laisse plus de liberté au niveau des conversion implicites.

Quelle est la méthode la plus recommandée, entre les rendre amies ou simplement en faire des wrappers de fonctions publiques?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Fraction
{
    ...
public:
    Fraction   ajoutEntier(const int &);
};
 
inline Fraction operator+(const Fraction &x, const int &y)
{
    return x.ajoutEntier(y);
}
inline Fraction operator+(const int &x, const Fraction &y)
{
    return y.ajoutEntier(x);
}

30/05/2013, 14h11
cknaky

Citation:

Envoyé par haraelendil

oui c'est normal, il ne faut définir ton opérateur qu'une fois, soit par une fonction membre, soit par une fonction libre, ça ne sert à rien de faire les deux.
Généralement, on préfère les définir en tant que fonction libre précisément pour le cas que tu montre ici, ça laisse plus de liberté au niveau des conversion implicites.

Merci de cette réponse. Mais une autre me vient à l'esprit puisque je n'ai pas encore attaqué l'opérateur -. Qu'est ce qui va permettre dans ce cas là de distinguer F1 - 1 et 1 - F1. Parce que dans l'addition cela n'a aucune importance. Alors que dans la surcharge de l'opérateur de soustraction là ça change tout.
30/05/2013, 14h27
Luc Hermitte

En première approximations, la plus recommandée est d'écrire un seul op+, libre, en termes de op+= (membre).
(après on peut vouloir optimiser ou être contraints par des templates à écrire toutes les surcharges de op+ (en libre toujours))
30/05/2013, 14h28
therwald

Citation:

Mais une autre me vient à l'esprit puisque je n'ai pas encore attaqué l'opérateur -. Qu'est ce qui va permettre dans ce cas là de distinguer F1 - 1 et 1 - F1.

Je suppose que tu n'as pas montré tout ton code et que tu as un constructeur du type:

Code:

Fraction(int entier);

ou alors:

Code:

Fraction(int num,int den=1);

?
Dans ce cas, ça permet de ramener le cas F+int au cas F+F par conversion automatique. Cela n'empêche pas qu'il prend les arguments dans l'ordre où tu les donnes, sans les inverser.
30/05/2013, 14h28
ternel

En fait, tu auras une conversion de 1 en fraction, si possible (si le constructeur n'est pas "explicit")

Sauf si tu t'amuses à définir 25 surcharges de operator-().
30/05/2013, 14h43
cknaky

Citation:

Envoyé par therwald

Je suppose que tu n'as pas montré tout ton code et que tu as un constructeur du type:

Code:

Fraction(int entier);

ou alors:

Code:

Fraction(int num,int den=1);

?
Dans ce cas, ça permet de ramener le cas F+int au cas F+F par conversion automatique. Cela n'empêche pas qu'il prend les arguments dans l'ordre où tu les donnes, sans les inverser.

Oui effectivement j'ai ces deux constructeurs dans mon code. De toute façon je vais m'y atteler et si je rencontre un problème je le soumettrais. Merci