Probleme sur ma classe Fraction

Version imprimable

Cheres amies et amis du forum

J'ai recupere une classe C++ pour le calcul de fraction, cependant lorsque j'effectue une opération il me retourne une abération (voir image)

En gros les affectations au variable fraction fonctionne mais lorsque le calcul s'effectue l'operateur surchargé "=" n'affecte pas la valeur, ou l'operateur surchargé "<< " n'affiche pas le resultat du calcul

voici le bout de code impliquer

fraction.h

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
 
class Fraction
{
   int Num;
   int Denom;
public :
//constructeurs
   Fraction(const int, const int);
   Fraction(const int);
   Fraction();
//Opérateuns d'action
   Fraction& operator+(const Fraction&);
   Fraction& operator+(const int&);
   Fraction& operator=(const Fraction&);
   Fraction& operator=(const int&);
 
//Fonctions amies
   friend ostream& operator<<(ostream&, Fraction&);   //opérateurs de flux (ex : cout)
   friend istream& operator>>(istream& , Fraction&);  //opérateurs de flux (ex : cin)
   friend int Pgcd(const int&,const int&); // trouve le plus grand diviseur commun entre i1 et i2
//Fonctions diverses
   Fraction& Simp();                      //Simplifie une fraction
   Fraction& Puis(const int&);            //comme un opérateur puissance
   Fraction& Inv();                       //Inverse la fraction
   int Signe();                           // 1 = positif ou nul      -1 = négatif
   void MemeDenom(Fraction&,Fraction&);   // met les deux fractions au meme dénominateur

fraction.cpp

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
//##########################____CONSTRUCTEURS____###############################
Fraction::Fraction(const int Numerateur,const int Denominateur)
{
   Num=Numerateur;
   Denom =Denominateur;
}
//##############################################################################
Fraction::Fraction()
{
   Num=0;
   Denom=1;
}
//##############################################################################
Fraction::Fraction(const int Entier)
{
   Num=Entier;
   Denom =1;
}
 
fonction de classe
 
Fraction& Fraction::operator+(const Fraction &F)
{
   Fraction FRes = *this;
   Fraction FInter = F;
   MemeDenom(FInter, FRes);
   FRes.Num += FInter.Num;
   return FRes.Simp();
}
 
Fraction& Fraction::operator=(const Fraction &F)
{	
    Num=F.Num;
   Denom=F.Denom;
   return *this;
}
 
ostream& operator<<(ostream& out, Fraction& F)
{	
	out << F.Num << "/" << F.Denom;
	return out;
}

Merci

03/11/2009, 10h00
3DArchi

Salut,
La spécialisation de l'opérateur + retourne une référence vers un temporaire. Or le temporaire est détruit à la sortie de la fonction. Donc les valeurs deviennent invalides.
03/11/2009, 16h03
Nono Sto

merci
aurais tu une solution SVP
03/11/2009, 17h52
3DArchi

retourner par valeur

Salut,

Je voudrais attirer ton attention sur le fait que l'opérateur = est l'opérateur d'affectation, et qu'il n'a donc un sens que lorsqu'il prend comme argument... un objet du type à affecter (de type Fraction const, dans le cas présent)

Il n'y a donc aucun intérêt de créer un opérateur d'affectation prenant un entier comme argument du simple fait que cette conversion est... prise en charge par le constructeur ad-hoc ;)

Par contre, les opérateurs mathématique d'addition (operator +) et de soustraction (operator -)

Ce sont les opérateur d'addition et affectation (operator +=) et de soustraction et affectation (operator -=), voire, les opérateur d'incrémentation (operator ++) et de décrémentation (operator --) qui renvoient, effectivement, l'objet courent ;)

De plus, pour ce qui est de l'opérateur <<, tu peux (et c'est fortement conseillé) passer ta fraction sous la forme d'une référence constante: l'affichage s'engageant à ne pas modifier le contenu de la fraction ;)

En outre, il ne sert généralement pas à grand chose de passer les types primitifs (comme les int) sous la forme de référence... leur copie ne coutant pas grand chose ;)

A titre personnel, je choisirais enfin des noms un tout petit peu plus explicite pour les différentes fonctions que tu envisage:
j'hésite à proposer PlusGrandCommunDiviseur pour pgcd, mais

Simplifie au lieu de Simp
Puissance au lieu de Puis
Inverse au lieu de Inv
seront à mon sens bien plus compréhensibles et te faciliteront énormément la lecture du code si, dans trois mois ou un an, tu décide de te replonger dans le code :D

Enfin, étant donné que tu ne renvoie finalement que deux valeur pour la fonction signe, pourquoi ne pas renvoyer directement une variable qui ne peut contenir que deux valeur: le booléen :question:

Pour que la réponse garde un sens, tu remplacerait la fonction signe par estPositive(), avec comme retour vrai si la fraction est effectivement positive et faux... si elle ne l'est pas.

Ce serait toujours mieux que d'avoir une valeur prise parmi des millions d'autres indiquant un signe positif, une autre toujours prise parmi des millions d'autres indiquant un signe négatif et les millions d'autres restant inutilisées :D

Allez, une dernière remarque pour la route: Tu devrais prendre l'habitude de travailler avec les listes d'initialisation.

En effet, les membres d'une classe sont initialisés entre la parenthèse qui ferme la liste d'arguments et l'accolade ouvrante qui représente le début du code du constructeur.

La manière dont tu crées tes constructeurs fait donc travailler en deux temps: une première initialisation (à zéro, c'est garanti par la norme) des membre entre la parenthèse fermante et l'accolade ouvrante, suivie d'une affectation dans le code.

Dans le cas présent, cela ne pose pas trop de problèmes, car les membres de ta classes sont des primitifs, mais, dans d'autres cas cela peut réellement plomber les performances, voire (dans le cas de types non assignables) carrément être refusé à la compilation.

Au final, ton code devrait se présenter sous la forme de
fraction.h
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 29 30 31 32 33 34 35 36 37 38 39 40 41 class Fraction { public: // constructeur par défaut Fraction(); // constructeur depuis un entier Fraction(int num); // constructeur depuis un numerateur et un dénominateur Fraction(int num, int denom); // addition de deux fractions Fraction operator + (Fraction const &); // addition d'une fraction et d'un entier Fraction operator + (int entier); Fraction & operator+=(Fraction const &); Fraction & operator +=(int entier); double Puissance (int entier); /* ne serait il pas plus cohérent pour ces deux fonctions de renvoyer * un nouvel objet qui soit respectivement l'objet courent inversé * et l'objet courent simplifié, histoire de garder l'objet courent * d'origine, en cas de besoin ?? */ void inverse(); void simplifie(); /* Même s'il s'agit d'une fonction de travail avec des Fractions, * tu n'a pas besoin de disposer d'une instance de fraction * pour calculer le pgcd entre deux entiers... */ static int pgcd(int, int); /* idem s'il s'agit de mettre deux fraction au même dénominateur */ static void memeDenominateur(Fraction &, Fraction &); /* à moins que tu ne veuille mettre la fraction courante et une * autre fraction au même dénominateur... dans ce cas, ce serait */ void memeDenominateur(Fraction &); friend std::ostream & operator<<(std::ostream&, Fraction const &); friend std::istream & operator>>(std::istream &, Fraction &); private: int numerateur_; int denominateur_; };
Et l'implémentation prendrait la forme de
Fraction.cpp
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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 #include "Fraction.h" /* cstdlib est intéressant pour avoir la fonction abs qui calcule la valeur * absolue d'un entier */ #include <cstdlib> Fraction::Fraction():numerateur_(0),denominateur_(1) { } Fraction::Fraction(int entier):numerateur_(entier),denominateur_(1) { } Fraction::Fraction(int num, int denom): numerateur_(num),denominateur_(denom) { } Fraction Fraction::operator+(Fraction const & f) { int num=(numerateur_*f.denominateur_) + (f.numerateur_*denominateur_); int denom=(denominateur_*f.denominateur_); Fraction ret(num,denom); return ret; } Fraction Fraction::operator+(int entier) { int num=(entier*denominateur_)+numerateur_; Fraction ret=(num,denominateur_); return ret; } Fraction& Fraction::operator +=(Fraction const & f) { Fraction temp=(*this)+f; numerateur_=temp.numerateur_; denominateur_=temp.denominateur_; return (*this); } Fraction& Fraction::operator +=(int entier) { Fraction temp=(*this)+entier; numerateur_=temp.numerateur_; denominateur_=temp.denominateur_; return (*this); } int Fraction::pgcd(int i1, int i2) { int more; int less; /* la valeur renvoyée ne sera en aucun cas supérieure à la valeur * du plus petit des deux entiers donnés... */ if(i1<i2) { more=abs(i2); less=abs(i1); } else { more=abs(i1); less=abs(i2); } /* parcourons en ordre inverse toutes les valeurs comprises entre * la valeur la plus petite et 1 */ for(int i=less;i>1;--i) { /* si le reste de la division des deux entiers fournis par la valeur * actuelle est égale à 0, nous avons le plus grand commun diviseur */ int restmore=more%i; int restless = less%i; if(restmore==0 && restless==0) return i; } /* S'il n'y en a pas d'autre, ce sera quoi qu'il en soit 1 */ return 1; } void Fraction::inverse() { int temp=numerateur_; numerateur_=denominateur_; denominateur_=temp; /* nous aurions pu faire quelque chose proche de * numerateur_=^denominateur_; * denominateur_=^numerateur_; * numerateur_=^denominateur_; */ } void Fraction::simplifie() { int pg=pgcd(numerateur_,denominateur_); numerateur_/=pg; denominateur_/=pg; } void Fraction::memeDenominateur(Fraction & f) { numerateur_*=f.denominateur_; f.numerateur_*=denominateur_; denominateur_*=f.denominateur_; f.denominateur_=denominateur_; } void Fraction::memeDenominateur(Fraction & f1, Fraction & f2) { f1.memeDenominateur(f2); } std::ostream& operator<<(std::ostream& ofs,Fraction const & f) { ofs<<f.numerateur_<<"/"<<f.denominateur_; return ofs; }

04/11/2009, 12h23
Médinoc

Tu implémentes l'opérateur += en appelant l'opérateur +?
Je serais plutôt du genre à faire le contraire, sauf quand il y a des considérations de performance comme de l'allocation mémoire...
04/11/2009, 12h28
koala01

Citation:

Envoyé par Médinoc

Tu implémentes l'opérateur += en appelant l'opérateur +?
Je serais plutôt du genre à faire le contraire, sauf quand il y a des considérations de performance comme de l'allocation mémoire...

J'avouerai que je n'ai pas réfléchi à la question en ce qui concerne cette classe particulière, et que je suis simplement parti sur l'idée de ne pas réécrire deux fois le même code :aie:

Comme, pour l'instant, je suis justement sur un projet dans lequel il est intéressant de le faire dans cet ordre, je n'ai pas été voir plus loin en appliquant "de manière bête et méchante" un idiome proche du copy 'n swap ;)

Cheres amies, chers amis du forum
grace à vous j'ai bien avancé je souhaiterais vous soumettre ma classe fraction
qu'en pensez vous?

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#ifndef FractionH
#define FractionH
 
#include <math.h>
#include <iostream>
#include <cstdlib>
 
class Fraction
{
 
private:
        int m_numerateur;
        int m_denominateur;
public:
	//constructeurs
        Fraction();
        Fraction(int num);
        Fraction(int num, int denom);
	//destructeur
        ~Fraction();
	//Opérateuns d'action
		Fraction& operator*(const Fraction&);
		Fraction& operator*(const int&);
		Fraction operator + (Fraction const &);        
        Fraction operator + (int entier);
		Fraction& operator-(const Fraction&);
		Fraction& operator-(const int&);
		Fraction& operator/(const Fraction&);
		Fraction& operator/(const int&);
		Fraction& operator=(const Fraction&);
		Fraction& operator=(const int&);
	//Opérateurs de test
		bool operator>(const Fraction&);
		bool operator>(const int&);
		bool operator>=(const Fraction&);
		bool operator>=(const int&);
		bool operator<(const Fraction&);
		bool operator<(const int&);
		bool operator<=(const Fraction&);
		bool operator<=(const int&);
		bool operator==(const Fraction&);
		bool operator==(const int&);
		bool operator!=(const Fraction&);
		bool operator!=(const int&);
	//fonctions
		Fraction simplifie();
		Fraction& inverse();
		static int  pgcd(int, int);
	//Fonctions amies
		friend std::ostream & operator<<(std::ostream&, Fraction const &);
        friend std::istream & operator>>(std::istream &, Fraction &);
 
};
 
#endif

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
#include "Fraction.h"
 
Fraction::Fraction()
{
	m_numerateur=0;
	m_denominateur=1;
}
Fraction::Fraction(int entier)
{
	m_numerateur=entier;
	m_denominateur=1;
}
Fraction::Fraction(int num, int denom)
{
	m_numerateur=num;
	m_denominateur=denom;
}
Fraction::~Fraction()
{
 
}
std::ostream& operator<<(std::ostream& ofs,Fraction const & f)
{	
	if (f.m_numerateur == f.m_denominateur)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_denominateur==1)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_numerateur==0)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_numerateur<0 && f.m_denominateur<0  )
			{
				ofs<<abs(f.m_numerateur)<<"/"<<abs(f.m_denominateur);
				return ofs;	
			}
		else 
			{
				ofs<<f.m_numerateur<<"/"<<f.m_denominateur;
				return ofs;	
			}
}
std::istream& operator>>(std::istream& in , Fraction& F)
{
	in >> F.m_numerateur;
	in >> F.m_denominateur;
	return in;
}
 
Fraction Fraction::operator+(Fraction const & f)
{
    int num=(m_numerateur*f.m_denominateur) +
        (f.m_numerateur*m_denominateur);
    int denom=(m_denominateur*f.m_denominateur);
	Fraction ret(num,denom);
    return ret.simplifie();
}
Fraction Fraction::operator+(int entier)
{
    int num=(entier*m_denominateur)+m_numerateur;
    Fraction ret(num,m_denominateur);
	return ret.simplifie();
}
Fraction& Fraction::operator*(const Fraction &F)
{
   m_numerateur *= F.m_numerateur;
   m_denominateur *= F.m_denominateur;
   Fraction ret(m_numerateur,m_denominateur);
   return ret.simplifie();
}
Fraction& Fraction::operator*(const int &Entier)
{
   m_numerateur = m_numerateur * Entier;
   Fraction ret(m_numerateur,m_denominateur);
   return ret.simplifie();
}
 
Fraction& Fraction::operator-(const Fraction &F)
{
   int num=(m_numerateur*F.m_denominateur) -
        (F.m_numerateur*m_denominateur);
   int denom=(m_denominateur*F.m_denominateur);
   Fraction ret(num,denom);
   return ret.simplifie();
}
 
Fraction& Fraction::operator-(const int &Entier)
{
   int num=m_numerateur-(Entier*m_denominateur);
   Fraction ret(num,m_denominateur);
   return ret.simplifie();
}
Fraction& Fraction::operator/(const Fraction &F)
{	
	m_numerateur *= F.m_denominateur;
	m_denominateur *= F.m_numerateur;
	Fraction ret(m_numerateur,m_denominateur);
    return ret.simplifie();
}
Fraction& Fraction::operator/(const int &Entier)
{
   m_denominateur *= Entier;
   Fraction ret(m_numerateur,m_denominateur);
   return ret.simplifie();
}
Fraction& Fraction::operator=(const Fraction &F)
{
   m_numerateur=F.m_numerateur;
   m_denominateur=F.m_denominateur;
   return *this;
}
Fraction& Fraction::operator=(const int& Entier)
{
   m_numerateur=Entier;
   m_denominateur=1;
   return *this;
}
bool Fraction::operator>(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) > (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator>(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) > Entier)
			{
				test = true;
			}
   return test;
}
bool Fraction::operator>=(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) >= (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator>=(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) >= Entier)
			{
				test = true;
			}
   return test;
}
bool Fraction::operator<(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) < (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator<(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) < Entier)
			{
				test = true;
			}
   return test;
}
bool Fraction::operator<=(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) <= (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator<=(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) <= Entier)
			{
				test = true;
			}
   return test;
}
bool Fraction::operator==(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) == (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator==(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) == Entier)
			{
				test = true;
			}
   return test;
}
bool Fraction::operator!=(const Fraction &F)
{
   bool test = false;
   Fraction F1(*this),F2(F);
   if ((F1.m_numerateur/F1.m_denominateur) != (F2.m_numerateur/F2.m_denominateur))
			{
				test = true;
			}
   return test;
}
bool Fraction::operator!=(const int &Entier)
{
   bool test = false;
   Fraction F1(*this);
   if ((F1.m_numerateur/F1.m_denominateur) != Entier)
			{
				test = true;
			}
   return test;
}
 
Fraction Fraction::simplifie()
{
    int pg=pgcd(m_numerateur,m_denominateur);
    m_numerateur/=pg;
    m_denominateur/=pg;
	Fraction ret(m_numerateur,m_denominateur);
	return ret;
}
 
int Fraction::pgcd(int i1, int i2)
{
    int more;
    int less;
    /* la valeur renvoyée ne sera en aucun cas supérieure à la valeur
     * du plus petit des deux entiers donnés...
     */
    if(i1<i2)
    {
        more=abs(i2);
        less=abs(i1);
    }
    else
    {
        more=abs(i1);
        less=abs(i2);
    }
    /* parcourons en ordre inverse toutes les valeurs comprises entre
     * la valeur la plus petite et 1
     */
    for(int i=less;i>1;--i)
    {
        /* si le reste de la division des deux entiers fournis par la valeur
         * actuelle est égale à 0, nous avons le plus grand commun diviseur
         */
        int restmore=more%i;
        int restless = less%i;
        if(restmore==0 && restless==0)
            return i;
    }
    /* S'il n'y en a pas d'autre, ce sera quoi qu'il en soit 1 */
   return 1;
}
Fraction& Fraction::inverse()
{	
   int num;
   int denom;
   Fraction ret(num,denom);
   ret.m_numerateur = denom;
   ret.m_denominateur = num;
   return ret.simplifie();
}

15/11/2009, 11h03
Nono Sto

j'ai oublier de vous demander:
j'ai surcharger les operateur +/*- pour les opération sur les fractions et les entier
cependant je ne peux faire des opérations que dans un sens c-a-d:
1/2+1 sa marche, mais 1+1/2 sa marche pas
est ce que je dois surcharger à nouveaux les opérateur pour pouvoir faire ce type d'opéations

Il y a assez bien à dire sur ton code, parce qu'il ne compile pas...

J'en fais la liste plus ou moins exhaustive :D

[1] Il n'y a aucun intérêt à passer les types primitifs (char, short, int, long, long long, float, double et leur équivalent signed / unsigned) sous la forme de référence...

Tu peux donc les passer par valeur ;)

[2] Une erreur que tu commet partout, c'est de renvoyer une référence sur tes opérateurs mathématiques.

[2 bis]Tu as oublié systématiquement les opérateurs mathématique avec affectation (ceux qui te permettent d'écrire, par exemple mafraction+=autrefraction )

[2ter]Lorsque tu définis ces opérateurs, tu modifie systématiquement le numérateur et le dénominateur de la fraction d'origine.

Or, les opérateur +, - , * et / renvoient une nouvelle fraction (comprend pas une référence), ce sont les opérateur +=, -=, *=, /= qui renvoient une référence sur l'objet courent.

Ce que tu peux faire pour les opérateurs mathématique sans affectation, c'est de travailler dans l'ordre précis suivant:

créer une copie de l'objet courent
renvoyer le résultat de l'opérateur mathématique avec affectation sur cette copie
L'opérateur + serait donc implémenté sous la forme de
Code:

1 2 3 4 5 6 7 8 9 /* l'opérateur + peut être déclaré constant car il s'engage à ne * pas modifier la fonction courente */ Fraction /* pas de référence */ Fraction::operator+(Fraction const &F) const { /*création d'une copie à l'aide du constructeur par copie */ Fraction temp(*this); return temp+=f; }
en ayant l'opérateur += implémenté sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /* par contre, l'opérateur += n'est pas constant car il modifie * la fraction courente */ Fraction & Fraction::operator+=(Fraction const & f) { int resnum = (m_numerateur* F.m_denominateur) + (F.m_numerateur* m_denominateur); m_numerateur=resnum; m_denominateur*=f.m_numerateur; simplifie(); return (*this); }
(les autres opérateurs étant dans la même veine en adaptant le calcul quand même :D )

[3]Ta fonction inverse devrait renvoyer un nouvel objet et, comme il s'agit "simplement" d'inverser le numérateur et le dénominateur, tu pourrais très bien l'implémenter sous la forme de (pourquoi faire simple quand on peut faire compliqué :question::D)
Code:

1 2 3 4 5 6 7 8 /* cette fonction peut être déclarée constante, étant donné qu'elle * ne modifie pas la fraction en cours mais renvoie une nouvelle fraction */ Fraction Fraction::inverse() const { Fraction temp(m_denominateur,m_numerateur); return temp.simplifie(); }
[4]Il ne sert à rien de créer ton propre opérateur =, le compilateur s'en charge pour toi, et les constructeurs servent d'opérateur de conversion implicite dans le sens entier->fraction

[5]Les opérateurs de comparaison ( <, >, == "and co") devraient être déclarés constants, car il se peut que tu doive parfois comparer des fractions constantes

De plus, tu te fais parfois du mal pour rien: les deux seuls opérateurs qu'il te faille réellement créer étant les opérateur < et == sous une forme proche de
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 29 30 31 32 33 34 35 36 37 38 39 bool Fraction::operator==(Fraction const & F) const { /* créons deux variables temporaires nous permettant de simplifier * les deux fractions */ Fraction temp1(*this); Fraction temp2(F); /* et simplifions les */ temp1.simplifie(); temp2.simplifie(); /* à ce stade, les fraction sont égales si les numérateurs et les * dénominateurs sont respectivement égaux */ return temp1.m_numerateur== temp2.m_numerateur && temp1.m_denominaleur==temp2.m_denominateur; } bool Fraction::operator<(Fraction const & F) const { /* le plus simple est, très certainement, de comparer le résultat du * calcull ;) * * Seulement, la division sur des entiers donne un entier... * * Si le résultat de la division est déjà plus petit, nous pouvons * être sur que la fraction en cours est plus petite que la fraction * avec laquelle nous tentons la comparaison */ if(m_numerateur/m_denominateur < F.m_numerateur/F.m_denominateur) return true; /* l'inverse est vrai aussi */ if(F.m_numerateur/F.m_denominateur<m_numerateur/m_denominateur) return false; /* si nous arrivons ici, c'est qu'il faut s'intéresser au reste de la division * * plus ce reste est grand, plus la fraction est grande */ return (m_numerateur %m_denominateur <F.m_numerateur%F.m_denominateur); }
les autres se basant sur ces deux premiers, sous des formes proches de
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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 bool Fraction::operator==(int Entier) const { return *this==Fraction(Entier); } bool Fraction::operator!=(Fraction const & F) const { return !(*this==F); } bool Fraction::operator!=(int Entier) const { return !(*this==Fraction(Entier)); } bool Fraction::operator::<(int Entier) const { return (*this<Fraction(Entier); } /* pour les opérateur >, il suffit d'inverser les deux termes : * si F1 est plus petit que F2, alors F2 est... plus grand que F1 */ bool Fraction::operator>(Fraction const & F) const { return F<(*this); } bool Fraction::operator>(int Entier) const { return Fraction(Entier)<(*this); } /* pour les opérateur <= et >=, il faut inverser le résultat de l'opérateur * sans égalité contraire correspondant) : * si F1 n'est pas plus petit que F2, F1 est, d'office, plus grand ou égal * à F2, et inversément: si F1 n'est pas plus grand que F2, il est d'office * plus petit ou égal */ bool Fraction::operator<=(Fraction const & F)const { return !(*this>F); } bool Fraction::operator<=(int Entier) const { return !(*this>Fraction(Entier)); } bool Fraction::operator>=(Fraction const & F) const { return !(*this<F); } bool Fraction::operator>=(int Entier) const { return !(*this<Fraction(Entier)); }
[6]Pour, quand même répondre à ta question, tu dois définir des opérateur +,-,* et / amis (friend) un peu à la manière de ce que tu a fais pour les opérateur << et >> sous une forme proche de
Code:

1 2 3 4 5 6 7 /* dans la définition de la classe */ friend Fraction operator+(int, Fraction const &) ; /* et l'implémentation */ Fraction operator+(int Entier, Fraction const & F) { return Fraction(Entier)+F; }
les autre étant dans la même veine ;)

16/11/2009, 01h18
Nono Sto

merci pour tes conseil
je vais retourner à mes codes

Merci et sorry pour le retard je croule sous le travail
voici ma nouvelle classe avec tes recommandation
sa compile nickel j'ai même zéro avertissements.

cependant j'ai plusieurs question :
1) lors de la surcharge de "<" j'ai différemment par rapport à toi, j'ai forcer le changement de type en float, le compilateur ne bronche meme pas, j'ai pas meme d'avertissement, qu'en pense tu?

Code:

1
2
3
4
5
6
7
bool Fraction::operator<(Fraction const & F) const
{
	if(float(m_numerateur)/float(m_denominateur) <  float(F.m_numerateur)/float(F.m_denominateur))
        return true;
	else 
		return false;
}

2)Pourquoi pour les fonctions amies on surcharge les operateur d'action à partir de la classe fraction

Code:

friend Fraction operator+(int, Fraction const &);

et les opérateurs de test a partir de int

Code:

friend int operator==(int, Fraction const &);

3)Enfin la suite de l'exercice est la création d'une fonction qui génère aléatoirement des opérations de deux chiffres (entier et fractions, fraction et fraction et fractions et entier), cependant je ne sais pas comment faire pour avoir des chiffres compatible, cad des opération réductible car piur compliquer les exo afficher des réponses non réduite.
en gros j'ai deux options : ou rand() dans l'intervalle (2,100) ou j'utilise un tableau ou il est enregistré tous les chiffre non premier avec tous leur diviseur.

Merci

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#ifndef FractionH
#define FractionH
 
#include <math.h>
#include <iostream>
#include <cstdlib>
 
class Fraction
{
 
private:
        int m_numerateur;
        int m_denominateur;
public:
	//constructeurs
        Fraction();
        Fraction(int num);
        Fraction(int num, int denom);
	//destructeur
        ~Fraction();
	//Opérateuns d'action
		Fraction operator * (Fraction const &) const;
		Fraction & operator *= (Fraction const &);
		Fraction operator + (Fraction const &) const;
		Fraction & operator += (Fraction const &); 
		Fraction operator-(const Fraction&) const;
		Fraction & operator -= (Fraction const &);
		Fraction operator/(const Fraction&) const;
		Fraction & operator /= (Fraction const &);
	//Opérateurs de test
		bool Fraction::operator==(Fraction const & F)const;
		bool Fraction::operator!=(Fraction const & F)const;
		bool Fraction::operator<=(Fraction const & F)const;
		bool Fraction::operator>=(Fraction const & F)const;
		bool Fraction::operator<(Fraction const & F) const;
		bool Fraction::operator>(Fraction const & F) const;
		bool Fraction::operator==(int Entier) const;
		bool Fraction::operator!=(int Entier) const;		
		bool Fraction::operator<=(int Entier) const;		
		bool Fraction::operator>=(int Entier) const;
		bool Fraction::operator<(int Entier) const;
		bool Fraction::operator>(int Entier) const;
	//fonctions
		Fraction simplifie();
		Fraction inverse() const;
		static int  pgcd(int, int);
	//Fonctions amies
		friend std::ostream & operator<<(std::ostream&, Fraction const &);
        friend std::istream & operator>>(std::istream &, Fraction &);
		friend Fraction operator+(int, Fraction const &);
		friend Fraction operator-(int, Fraction const &);
		friend Fraction operator*(int, Fraction const &);
		friend Fraction operator/(int, Fraction const &);
		friend int operator==(int, Fraction const &);
		friend int operator!=(int, Fraction const &);
		friend int operator<=(int, Fraction const &);
		friend int operator>=(int, Fraction const &);
		friend int operator<(int, Fraction const &);
		friend int operator>(int, Fraction const &);
};
 
#endif

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
#include "Fraction.h"
 
Fraction::Fraction()
{
	m_numerateur=0;
	m_denominateur=1;
}
Fraction::Fraction(int entier)
{
	m_numerateur=entier;
	m_denominateur=1;
}
Fraction::Fraction(int num, int denom)
{
	m_numerateur=num;
	m_denominateur=denom;
}
Fraction::~Fraction()
{
 
}
std::ostream& operator<<(std::ostream& ofs,Fraction const & f)
{	
	if (f.m_numerateur == f.m_denominateur)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_denominateur==1)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_numerateur==0)
			{
				ofs<<f.m_numerateur;
				return ofs;
			}
	else if (f.m_numerateur<0 && f.m_denominateur<0  )
			{
				ofs<<abs(f.m_numerateur)<<"/"<<abs(f.m_denominateur);
				return ofs;	
			}
		else 
			{
				ofs<<f.m_numerateur<<"/"<<f.m_denominateur;
				return ofs;	
			}
}
std::istream& operator>>(std::istream& in , Fraction& F)
{
	in >> F.m_numerateur;
	in >> F.m_denominateur;
	return in;
}
Fraction Fraction::operator+(Fraction const &F) const 
{
    Fraction temp(*this);
    return temp+=F;
}
Fraction & Fraction::operator+=(Fraction const & F)
{
    int resnum = (m_numerateur* F.m_denominateur) + 
                 (F.m_numerateur* m_denominateur);
    m_numerateur=resnum;
    m_denominateur*=F.m_denominateur;
    simplifie();
    return (*this);
}
Fraction Fraction::operator*(Fraction const &F) const 
{
    Fraction temp(*this);
    return temp*=F;
}
Fraction & Fraction::operator*=(Fraction const & F)
{
    m_numerateur *= F.m_numerateur;
	m_denominateur *= F.m_denominateur;
    simplifie();
    return (*this);
}
Fraction Fraction::operator-(Fraction const &F) const
{
    Fraction temp(*this);
    return temp-=F;
}
Fraction & Fraction::operator-=(Fraction const & F)
{
    int resnum = (m_numerateur* F.m_denominateur) - 
                 (F.m_numerateur* m_denominateur);
    m_numerateur=resnum;
    m_denominateur*=F.m_denominateur;
    simplifie();
    return (*this);
}
Fraction Fraction::operator/(Fraction const &F) const
{
    Fraction temp(*this);
    return temp/=F;
}
Fraction & Fraction::operator/=(Fraction const & F)
{
    m_numerateur *= F.m_denominateur;
	m_denominateur *= F.m_numerateur;
    simplifie();
    return (*this);
}
bool Fraction::operator==(Fraction const & F) const
{
    Fraction temp1(*this);
    Fraction temp2(F);
    temp1.simplifie();
    temp2.simplifie();
    return temp1.m_numerateur== temp2.m_numerateur && 
           temp1.m_denominateur==temp2.m_denominateur;
}
bool Fraction::operator<(Fraction const & F) const
{
	if(float(m_numerateur)/float(m_denominateur) <  float(F.m_numerateur)/float(F.m_denominateur))
        return true;
	else 
		return false;
}
bool Fraction::operator==(int Entier) const
{
    return *this==Fraction(Entier);
}
bool Fraction::operator!=(Fraction const & F) const
{
    return !(*this==F);
}
bool Fraction::operator!=(int Entier) const
{
    return !(*this==Fraction(Entier));
}
bool Fraction::operator<(int Entier) const
{
    return (*this<Fraction(Entier));
}
bool Fraction::operator>(Fraction const & F) const
{
    return F<(*this);
}
bool Fraction::operator>(int Entier) const
{
    return Fraction(Entier)<(*this);
}
bool Fraction::operator<=(Fraction const & F)const
{
    return !(*this>F);
}
bool Fraction::operator<=(int Entier) const
{
    return !(*this>Fraction(Entier));
}
bool Fraction::operator>=(Fraction const & F) const
{
   return !(*this<F);
}
bool Fraction::operator>=(int Entier) const
{
    return !(*this<Fraction(Entier));
}
Fraction operator+(int Entier, Fraction const & F)
{
    return Fraction(Entier)+F;
}
Fraction operator-(int Entier, Fraction const & F)
{
    return Fraction(Entier)-F;
}
Fraction operator*(int Entier, Fraction const & F)
{
    return Fraction(Entier)*F;
}
Fraction operator/(int Entier, Fraction const & F)
{
	return Fraction(Entier)*F.inverse();
}
int operator==(int Entier, Fraction const & F)
{
    return Fraction(Entier)==F;
}
int operator!=(int Entier, Fraction const & F)
{
    return Fraction(Entier)!=F;
}
int operator<=(int Entier, Fraction const & F)
{
    return Fraction(Entier)<=F;
}
int operator>=(int Entier, Fraction const & F)
{
    return Fraction(Entier)>=F;
}
int operator<(int Entier, Fraction const & F)
{
    return Fraction(Entier)<F;
}
int operator>(int Entier, Fraction const & F)
{
    return Fraction(Entier)>F;
}
 
Fraction Fraction::simplifie()
{
    int pg=pgcd(m_numerateur,m_denominateur);
    m_numerateur/=pg;
    m_denominateur/=pg;
	Fraction ret(m_numerateur,m_denominateur);
	return ret;
}
int Fraction::pgcd(int i1, int i2)
{
    int more;
    int less;
    /* la valeur renvoyée ne sera en aucun cas supérieure à la valeur
     * du plus petit des deux entiers donnés...
     */
    if(i1<i2)
    {
        more=abs(i2);
        less=abs(i1);
    }
    else
    {
        more=abs(i1);
        less=abs(i2);
    }
    /* parcourons en ordre inverse toutes les valeurs comprises entre
     * la valeur la plus petite et 1
     */
    for(int i=less;i>1;--i)
    {
        /* si le reste de la division des deux entiers fournis par la valeur
         * actuelle est égale à 0, nous avons le plus grand commun diviseur
         */
        int restmore=more%i;
        int restless = less%i;
        if(restmore==0 && restless==0)
            return i;
    }
    /* S'il n'y en a pas d'autre, ce sera quoi qu'il en soit 1 */
   return 1;
}
Fraction Fraction::inverse() const
{
   Fraction temp(m_denominateur,m_numerateur);
   return temp.simplifie();
}

25/11/2009, 14h05
Luc Hermitte
Citation:
Envoyé par koala01

[2]

Code:

1 2 3 4 /* l'opérateur + peut être déclaré constant car il s'engage à ne * pas modifier la fonction courante */ Fraction /* pas de référence */ Fraction::operator+(Fraction const &F) const

[6]Pour, quand même répondre à ta question, tu dois définir des opérateur +,-,* et / amis (friend) un peu à la manière de ce que tu a fais pour les opérateur << et >> sous une forme proche de
[code]/* dans la définition de la classe */
friend Fraction operator+(int, Fraction const &) ;
Voire même on va préférer la forme libre et symétrique qui supporte les éventuelles conversions implicites.
Code:

1 2 3 4 Fraction operator+(Fraction const& lhs, Fraction const &rhs) { return Fraction(lhs)+=rhs; } // qui peut encore être optimisé en prenant une copie à gauche si on n'inline pas
Accessoirement, grâce aux opérateurs x=, nul besoin d'amitié.