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
| #include <iostream>
#include <string>
using namespace std;
#include "Ratio.h"
int main()
{
cout << "1 : Construction de r1 avec deux paramètres entiers : le numerateur et le denominateur." << endl;
Ratio r1(1,4); // 1: Constructeur avec deux paramètres (numérateur et dénominateur).
cout << "2 : Construction de r2 avec un seul paramètre entiers : le numerateur." << endl
<< "On veut obtenir le rationnel équivalent a cet entier naturel." << endl
<< "Le denominateur du rationnel a construire est fixe a un." << endl;
Ratio r2(3); // 2: Constructeur avec un seul paramètre fabricant l'entier équivalent, ici 3/1.
cout << "3 : Construction de r3 sans aucun paramètre, ce qu'on appelle le constructeur par defaut." << endl
<< "Le numerateur est fixé à zero et le denominateur à un." << endl;
Ratio r3; // 3: Constructeur sans paramètre, équivalent à 0/1.
cout << "Sur le meme principe, construction de r4 et r5." << endl;
Ratio r4(1,4);
Ratio r5(5,6);
// 4: fonction membre Ratio::ecrire()
cout << endl << "4: Affichage avec Ratio::ecrire() :"<<endl;
cout << "un quart : r1="; r1.ecrire(); cout << endl;
cout << "trois : r2="; r2.ecrire(); cout << endl;
cout << "zero : r3="; r3.ecrire(); cout << endl;
// 5: fonction Ratio::affecter(int numerateur,int denominateur) avec valeurs par défaut identiques à celles du constructeur.
cout << endl << "5: Fonction Ratio::affecter()" << endl;
r2.affecter(2,3); cout << "deux tiers : r2="; r2.ecrire(); cout << endl;
r3.affecter(2); cout << "deux : r3="; r3.ecrire(); cout << endl;
r1.affecter(); cout << "zero : r1="; r1.ecrire(); cout << endl;
cout << "Affectation de 1/4 a r1." << endl;
r1.affecter(1,4); // Juste pour remettre une valeur non-nulle...
cout << "un quart : r1="; r1.ecrire(); cout << endl;
// 6: fonction Ratio::valeur_reelle().
/*
cout << endl << "6: Ratio::valeur_reelle()" << endl;
cout << "r2="; r2.ecrire(); cout << "=" << r2.valeur_reelle()
<< " <- Remarquez que le calcul est seulement une valeur approchée arondie : il faudrait une infinité de '6' après la virgule..." << endl;
*/
// 7: fonction Ratio::inverser().
/*
cout << endl << "7: Ratio::inverser()." << endl;
cout << "r3="; r3.ecrire();
r3.inverser();
cout << ". Inverser r3. r3="; r3.ecrire(); cout << '.' << endl;
*/
// 8: constructeur de copie
/*
cout << endl << "8: Construction de r comme copie de r1 :" << endl;
{
Ratio r(r1);
cout << " r="; r.ecrire(); cout << endl;
// Sur cette classe particulière, même si vous ne la faites pas, le constructeur fait automatiquement
// fonctionnera correctement : il suffit en effet de copier les données membres de l'une dans l'autre.
// Respectez cependant la consigne et ECRIVEZ DE TOUTES FACONS le constructeur de copie.
}
*/
// 9: affichage dans les constructeurs et ajout du destructeur.
// Ajouter le destructeur pour Ratio.
// Ajoutez des affichages sur cout dans les constructeurs et le destructeur pour indiquer
// quand ont lieu les constructions et les destructions. Cela ne se fait pas habituellement (les
// constructions et destructions sont silencieuses !) mais cela vous permettra de vérifier que
// vous avez compris.
// Comparez avec l'affichage obtenu avec le résultat obtenu avec le tp7.1.exe fourni.
/*
{
cout << endl << "9: Construction de 4/5 :" << endl;
Ratio r(4,5);
cout << "Destruction de 4/5 :" << endl;
}
*/
// 10: accesseurs numerateur() et denominateur() qui renvoient la valeur de la donnée membre correspondante.
/*
cout << endl << "10: Accesseurs :" << endl;
cout << "r2="; r2.ecrire(); cout << ", numérateur de r2 = " << r2.numerateur() << ", denominateur de r2 = " << r2.denominateur() << endl;
*/
// 11: s'assurer que toutes les fonctions qui ne modifient pas le Rationnel sont marquées en conséquence :
/*
{
const Ratio & r = r2; // Astuce pour faire que le nouveau nom r corresponde dans ce bloc à une version constante de r2.
cout << endl << "11: operations constantes :" << endl;
cout << "r="; r.ecrire(); cout << "=" << r.valeur_reelle() << endl;
cout << "accesseurs : r.numerateur()->"<< r.numerateur() << ", r.denominateur()->" << r.denominateur() << "." << endl;
}
*/
// 12: operateur << pour les Ratio
// Une fois que vous savez faire celui-là, aucune raison sur vos prochaines classes de faire la fonction membre ecrire() !
/*
cout << endl << "12: operateur d'envoi sur un flux." << endl;
cout << "r1="<< r1 << endl;
*/
// 13: opérateur d'affectation
/*
cout << endl << "13: operateur d'affectation." << endl;
r2=r1; // affectation à partir d'une variable nommée.
cout << "La variable r1=" << r1 << " a bien ete affectee a r2=" << r2 << "." << endl;
*/
// 14: opérateurs arythmétiques
/*
cout << endl << "14: operateurs arythmétiques. " << endl
<< "(Il est normal d'avoir des constructions-destructions pour chaque résultat intermédiaire, et vous devez identifier quand elles se produisent !)." << endl;
cout << "r4=" << r4 << ", r5=" << r5 << endl;
cout << r4 << " + " << r5 << " = " << r4+r5 << endl;
cout << endl;
cout << r4 << " - " << r5 << " = " << r4-r5 << endl;
cout << endl;
cout << r4 << " * " << r5 << " = " << r4*r5 << endl;
cout << endl;
cout << r4 << " / " << r5 << " = " << r4/r5 << endl;
cout << endl;
*/
// 15: autres opérateurs d'affectation
/*
{
cout << endl << "15: autres operateurs d'affectation." << endl;
r2=r4; r1=r5;
cout << "r1=" << r1 << ", r2=" << r2 << ", r3=" << r3 << endl;
r3 = r2 += r1; // r2 += r1 équivalent à r2 = r2 + r1;
cout << "* * * Remarquez qu'il n'y a pas ici de contruction-destruction ! * * *" << endl;
cout << "r3 = r2 += r1;"<< endl << "r1=" << r1 << ", r2=" << r2 << ", r3=" << r3 << endl;
r2=r4; r1=r5;
cout << endl << "r1=" << r1 << ", r2=" << r2 << endl;
r3 = r2 -= r1; // Idem avec -=
cout << "r3 = r2 -= r1;"<< endl << "r1=" << r1 << ", r2=" << r2 << ", r3=" << r3 << endl;
r2=r4; r1=r5;
cout << endl << "r1=" << r1 << ", r2=" << r2 << endl;
r3 = r2 *= r1; // Idem avec *=
cout << "r3 = r2 *= r1;"<< endl << "r1=" << r1 << ", r2=" << r2 << ", r3=" << r3 << endl;
r2=r4; r1=r5;
cout << endl << "r1=" << r1 << ", r2=" << r2 << endl;
r3 = r2 /= r1; // Idem avec /=
cout << "r3 = r2 /= r1;"<< endl << "r1=" << r1 << ", r2=" << r2 << ", r3=" << r3 << endl;
}
*/
// 16: Opérateurs de comparaison
/*
cout << endl << "16: operateurs de comparaison." << endl;
{
Ratio r(10,12);
if(r1 == r)
cout << r1 << "==" << r << endl; // Souvenez vous que 5/6 est égal à 10/12 !
if(r2 != r)
cout << r2 << "!=" << r << endl;
}
*/
// 17: Opérateurs de pré et post incrémentation et décrémentation.
/*
cout << endl << "17: Opérateurs de pré et post incrémentation et décrémentation." << endl;
{
Ratio r;
cout << endl << "r=" << r << ", r5=" << r5 << endl;
r = r5++;
cout << "r = r5++; "<< endl << "r=" << r << ", r5=" << r5 << endl;
r.affecter();
cout << endl << "r=" << r << ", r5=" << r5 << endl;
r = r5--;
cout << "r = r5--; "<< endl << "r=" << r << ", r5=" << r5 << endl;
cout << endl << "Les opérateurs suivants n'utilisent pas de variable locale, " << endl
<< "et se contentent de renvoyer une référence sur le rationnel courant." << endl;
r.affecter();
cout << "r=" << r << ", r5=" << r5 << endl;
r = ++r5;
cout << "r = ++r5; "<< endl << "r=" << r << ", r5=" << r5 << endl;
r.affecter();
cout << endl << "r=" << r << ", r5=" << r5 << endl;
r = --r5;
cout << "r = --r5; "<< endl << "r=" << r << ", r5=" << r5 << endl;
}
*/
// On arrive à la fin du main, donc les variables qui lui sont locales sont
// détruites. Pour les instances de Ratio (c'est-à-dire les variables du type
// Ratio) qui doivent être détruites, un appel au destructeur ~Ratio() est
// automatiquement effectué pour chacune d'entre elles.
/*
cout << endl << "9: Destruction de r1, r2 et r3:" << endl;
*/
return 0;
} |
