Discussion :

[cknaky]

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 :

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

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 :

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

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.

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

[Médinoc]

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

Code C++ :

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

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);
}

[cknaky]

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.

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

[therwald]

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 :

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

Fraction(int entier);

ou alors:

Code :

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

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.

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

[cknaky]

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

Code :

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

Fraction(int entier);

ou alors:

Code :

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

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