Je suis bloqué pour faire un operateur de flux

Bonjour,

Je suis un debutant en C++. J'essaie d'apprendre le C++ par moi-meme en lisant des tutorials. Je suis rendu au programme d'orientation d'objet(POO). Je suis en train de faire des operations de flux. Mais, mon IDE genere beaucoups d'erreurs que je ne comprends pas quelqu'un peut me les expliquer svp.

Erreur

Citation:

1>------ Début de la génération*: Projet*: projet, Configuration*: Debug Win32 ------
1>Compilation en cours...
1>Temps.cpp
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2544: attendu ')' pour l'opérateur '()'
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2146: erreur de syntaxe*: absence de ';' avant l'identificateur 'ostream'
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2530: '()'*: les références doivent être initialisées
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2530: 'monFlux'*: les références doivent être initialisées
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2143: erreur de syntaxe*: absence de ';' avant 'const'
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2512: 'std::basic_ostream<_Elem,_Traits>'*: aucun constructeur par défaut approprié disponible
1> with
1> [
1> _Elem=char,
1> _Traits=std::char_traits<char>
1> ]
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque*: C++ ne prend pas en charge int par défaut
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(289) : error C2059: erreur de syntaxe*: ')'
1>c:\users\tamere\documents\visual studio 2008\projects\mabite\projet\temps.cpp(290) : error C2470: 'a'*: similaire à une définition de fonction, mais aucune liste de paramètres*; corps apparent ignoré
1>Génération de code en cours...
1>Compilation en cours...
1>main.cpp
1>Génération de code en cours...
1>Le journal de génération a été enregistré à l'emplacement "file://c:\Users\tamere\Documents\Visual Studio 2008\Projects\mabite\projet\Debug\BuildLog.htm"
1>projet - 9 erreur(s), 0 avertissement(s)
========== Génération*: 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

Temps.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
42
43
44
45
46
47
48
49
50
#ifndef DEF_TEMPS
#define DEF_TEMPS
#include <iostream>
using namespace std;
 
/* Creation de la classe temps qui me permettera de calculer du temps avec le temps */
class Temps
{
	friend ostream &operator<<(ostream &monFlux, Temps const& a);
/* Les attributs du temps */
private:
	int m_semaine;
	int m_jour;
	int m_heure;
	int m_minute;
	int m_seconde;
	int m_secondeAbsolu;
 
/* Action que le temps peut faire */
public:
	Temps(int heure = 0,int minute = 0, int seconde = 0);
	void balancer();
	int get_secondeAbsolu() const; 
	int get_semaine() const;
	int get_jour() const;
	int get_heure() const;
	int get_minute() const;
	int get_seconde() const;
	void afficher(std::ostream &monFlux);
	Temps operator+=(const Temps& a);
	Temps operator+=(int seconde);
	Temps operator-=(const Temps& a);
	Temps operator-=(int seconde);
	Temps operator*=(const Temps& a);
	Temps operator*=(int seconde);
	Temps operator/=(const Temps& a);
	Temps operator/=(int seconde);
	void calculerSecondeAbsolu(int seconde = 0,int minute = 0,int heure= 0);
};
 
// Les operateurs a plus de 2 arguments puisque si je les mets dans la fonction, il y aura des erreurs
Temps operator+(Temps const& a, Temps const& b);
Temps operator+(Temps const& a, int seconde);
Temps operator-(Temps const& a, Temps const& b);
Temps operator-(Temps const& a, int seconde);
Temps operator*(Temps const& a, Temps const& b);
Temps operator*(Temps const& a, int seconde);
Temps operator/(Temps const& a, Temps const& b);
Temps operator/(Temps const& a, int seconde);
#endif

Temps.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
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
#include "Temps.h"
#include <iostream>
#include <string>
using namespace std;
 
// Construction du temps
Temps::Temps(int heure,int minute, int seconde)
{
	//Placer les parametre dans les attributs
	m_heure = heure;
	m_minute = minute;
	m_seconde = seconde;
	//Initialiser les attributs
	m_jour = 0;
	m_semaine = 0;
	m_secondeAbsolu = 0;
	//Calculer les secondes absolus
	calculerSecondeAbsolu(seconde,minute,heure);
}
 
//Calculer le nombre de seconde total
void Temps::calculerSecondeAbsolu(int seconde,int minute,int heure)
{
	//Si l'heure(en parametre) est plus que 0
	if(heure > 0)
	{
		//A chaque 1 heure(en parametre), la seconde absolu gagne 3600
		while(heure > 0)
		{
			heure -= 1;
			m_secondeAbsolu += 3600;
		}
	}
	//Si la minute(en parametre) est plus grand que 0
	if(minute > 0)
	{
		//A chaque 1 minute(en parametre), la seconde absolu gagne 60.
		while(minute > 0)
		{
			minute -= 1;
			m_secondeAbsolu += 60;
		}
	}
	//Rajouter le nombre de seconde dans la seconde absolu
	m_secondeAbsolu += seconde;
	//Balancer les unités de temps
	balancer();
}
 
//Balancer les unités de temps pour pas qu'il depasse leur capacité maximal
void Temps::balancer()
{
	//Reinitialiser les attributs
	m_heure = 0;
	m_minute = 0;
	m_jour = 0;
	m_semaine = 0;
	// Nous avons faite sa pour que toute les heures, minute, jour & semaine soit dans une meme variable(C'est plus facile a controler)
	m_seconde = m_secondeAbsolu;
	// Si le nombre de seconde est plus grand que 60
	if(m_seconde > 60)
	{
		// Rajouter 1 minute pour chaque 60 seconde de trop
		while(m_seconde > 60)
		{
			m_seconde -= 60;
			m_minute += 1;
		}
	}
	//Si le nombre de minute est plus grand que 60
	if(m_minute > 60)
	{
		// Rajouter 1 heure pour chaque 60 minute de trop
		while(m_minute > 60)
		{
			m_minute -= 60;
			m_heure += 1;
		}
	}
	//Si le nombre d'heure est plus grand que 24
	if(m_heure > 24)
	{
		// Rajouter 1 journee pour chaque 24 heure de trop
		while(m_heure > 24)
		{
			m_heure -= 24;
			m_jour += 1;
		}
	}
	// Si le nombre de jour est plus grand que 7
	if(m_jour > 7)
	{
		// Rajouter 1 semaine pour chaque 7 jour de trop
		while(m_jour > 7)
		{
			m_jour -= 7;
			m_semaine += 1;
		}
	}
}
 
// Retourne la seconde absolu
int Temps::get_secondeAbsolu() const
{
	return m_secondeAbsolu;
}
 
// Affiche le temps de maniere lisible
void Temps::afficher(ostream &monFlux)
{
	//Si il y a des semaines, on affiche le texte.
	if(m_semaine > 0)
	{
		monFlux << m_semaine << " semaine(s) ";
	}
	//Si il y a des journees, on affiche le texte.
	if(m_jour > 0)
	{
		monFlux << m_jour << " jour(s) ";
	}
	//Si il y a des heures, on affiche le texte.
	if(m_heure > 0)
	{
		monFlux << m_heure << " heure(s) ";
	}
	//Si il y a des minutes, on affiche le texte.
	if(m_minute > 0)
	{
		monFlux << m_minute << " minute(s) ";
	}
	//On affiche les secondes meme si qu'il ont a pas.
	monFlux << m_seconde << " seconde(s) " << endl;
}
 
int Temps::get_semaine() const
{
	return m_semaine;
}
 
int Temps::get_jour() const
{
	return m_jour;
}
 
int Temps::get_heure() const
{
	return m_heure;
}
 
int Temps::get_minute() const
{
	return m_minute;
}
 
int Temps::get_seconde() const
{
	return m_seconde;
}
 
// Additionner des Temps
Temps operator+(Temps const& a, Temps const& b)
{
	Temps copie(0,0,a.get_secondeAbsolu());
    copie += b;
	copie.balancer();
    return copie;
}
 
// Addtionner des Temps avec des int
Temps operator+(Temps const& a, int seconde)
{
	Temps copie(0,0,a.get_secondeAbsolu()+seconde);
    return copie;
}
 
// Soustraire des Temps
Temps operator-(Temps const& a, Temps const& b)
{
	Temps copie(0,0,a.get_secondeAbsolu());
    copie -= b;
	copie.balancer();
    return copie;
}
 
// Soustraire des Temps avec des int
Temps operator-(Temps const& a, int seconde)
{
	Temps copie(0,0,a.get_secondeAbsolu()-seconde);
    return copie;
}
 
// multiplier des Temps
Temps operator*(Temps const& a, Temps const& b)
{
	Temps copie(0,0,a.get_secondeAbsolu());
    copie *= b;
	copie.balancer();
    return copie;
}
 
// Multiplier des Temps avec des int
Temps operator*(Temps const& a, int seconde)
{
	Temps copie(0,0,a.get_secondeAbsolu()*seconde);
    return copie;
}
 
// Diviser des Temps
Temps operator/(Temps const& a, Temps const& b)
{
	Temps copie(0,0,a.get_secondeAbsolu());
    copie /= b;
	copie.balancer();
    return copie;
}
 
// Diviser des Temps avec des int
Temps operator/(Temps const& a, int seconde)
{
	Temps copie(0,0,a.get_secondeAbsolu()/seconde);
    return copie;
}
 
// Raccourcie pour additionner le temps
Temps Temps::operator+=(const Temps& a)
{
	m_secondeAbsolu += a.get_secondeAbsolu();
	balancer();
	return *this;
}
 
 
// Raccourcie pour additionner le temps avec des int
Temps Temps::operator+=(int seconde)
{
	m_secondeAbsolu += seconde;
	balancer();
	return *this;
}
 
// Raccourcie pour soustraire le temps
Temps Temps::operator-=(const Temps& a)
{
	m_secondeAbsolu -= a.get_secondeAbsolu();
	balancer();
	return *this;
}
 
// Raccourcie pour soustraire le temps avec des int
Temps Temps::operator-=(int seconde)
{
	m_secondeAbsolu -= seconde;
	balancer();
	return *this;
}
 
// Raccourcie pour multiplier le temps
Temps Temps::operator*=(const Temps& a)
{
	m_secondeAbsolu *= a.get_secondeAbsolu();
	balancer();
	return *this;
}
 
// Raccourcie pour multiplier le temps avec des int
Temps Temps::operator*=(int seconde)
{
	m_secondeAbsolu *= seconde;
	balancer();
	return *this;
}
 
// Raccourcie pour diviser le temps
Temps Temps::operator/=(const Temps& a)
{
	m_secondeAbsolu /= a.get_secondeAbsolu();
	balancer();
	return *this;
}
 
// Raccourcie pour diviser le temps avec des int
Temps Temps::operator/=(int seconde)
{
	m_secondeAbsolu /= seconde;
	balancer();
	return *this;
}
 
ostream &operator(ostream &monFlux, Temps const& a)
{
	a.afficher(monFlux);
	return monFlux;
}

main.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
#include <iostream>
#include "Temps.h"
using namespace std;
 
int main()
{
	// Declarer les objets
	Temps Total1;
	Temps Total2;
	Temps Total3;
	Temps TempsA(49,13,73);
	Temps TempsB(47,209,64);
	Temps TempsC(81,34,186);
	Temps TempsD(0,0,418686);
	Temps TempsE(24,60,60);
	Temps TempsF(3600,120,60);
 
	// Calculer le temps (Je calcule juste pour m'amuser)
	Total1 = TempsE/60;
	Total1 += 100;
	Total1 += TempsC;
	Total2 = TempsD + 81314;
	Total3 = TempsF*10;
	Total3 -= 60;
	Total3 -= TempsA;
 
 
	// Afficher les resultats
	cout << Total1;
 
	system("pause");
	return 0;
}