Discussion :

[Geolem]

Bonjour tout le monde.

J'ai denouveau un prob de surcharge, mais cette fois-ci avec les opérateurs << et >>.

En résumé, je dois encoder un mail et savoir le relir. A la place de faire des tas de cin et des tas de cout dans mes fonctions d'encodage et d'affichage, je dois faire appels aux surcharges de << et >>.

Alors, on commence dans mon header :

Code :

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

1
2
	friend ostream& operator<< (ostream& msgs, const message& m);
	friend istream& operator>> (istream& msgs, message& m);

bien placé au-dessus de tout de ma classe message :

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
29
30
31
32
class message
{
	friend ostream& operator<< (ostream& msgs, const message& m);
	friend istream& operator>> (istream& msgs, message& m);
	private:
		static int cpt_id_message; // compteur nombr id déjà utilisé
		int num_id_message;	// num id du message
		std::string adresse_expediteur;
		std::string adresse_destinataire;
		bool urgent;
		bool mess_lu;
		std::string sujet;
		std::string texte;
	public:
		message (void);					// constructeur par défaut
		message (std::string& ad_dest) {setDestinataire(ad_dest);}
		message (const message & mess);	// constructeur de copie
		message (int num, std::string& ad_exp, std::string& ad_dest, bool urg, bool msg_lu, std::string& sjt, std::string& txt);
 
		message operator+ (const std::string& ad_dest) const;   // surcharge de l'opérateur +
 
		void affMessage (void);	// afficher le message
		void encMessage (void);	// entrer le message
		void checkFormatMsg (std::string& tmpEnc);	// vérifie la présence d'un " @ " 
 
		void setExpediteur (const std::string& tmpEnc) {
			adresse_expediteur = tmpEnc; }
		void setDestinataire (const std::string& tmpEnc) {
			adresse_destinataire = tmpEnc; }
		const std::string& getDestinataire (void) {
			return adresse_destinataire; }
};

Ma fonction d'affichage :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
ostream& operator <<(ostream& msgs, const message& m)
{
	msgs << "ID message : " << m.num_id_message << endl 
		<< "Expediteur : " << m.adresse_expediteur << endl
		<< "Destinataire(s) : " << m.adresse_destinataire << endl
		<< "Urgent : " << m.urgent << endl
		<< "Lu : " << m.mess_lu << endl
		<< "Sujet : " << m.sujet << endl
		<< "Texte : " << m.texte << endl;
	return msgs;
}

qui est appellée par çà:

Code :

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

1
2
	message affMessage;
	cout << affMessage << endl;

Ma fonction d'encodage :

Code :

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

1
2
3
4
5
istream& operator >> (istream& msgs, message& m)
{
...// Où j'ai pris soin de faire précéder tous les encodages d'un "m."
return msgs;
};

qui est appellé par :

Code :

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

1
2
	message affMessage;
	cin >> affMessage;

Voilà... j'arrive à encoder... lorsque je fais des cout de chaque variables, y a qlq chose dedans, cependant, lorsque je fais un cout << msgs;, bah çà affiche rien hormis le contenu du constructeur par défaut.

Et encore une fois, durdur de trouver de la doc bien faite sur la surcharge de << et >>. Quelqu'un veut bien faire un tuto complet sur çà Cà serait apprécié par beaucoup de monde

[Geolem]

Yep, j'avais pas envisagé le prob, mais çà fonctionne dans un certain cas .

En faite, lorsqu'on met dans la même fonction, le cin >> msgs et le cout << msgs, çà fonctionne. Mais lorsqu'on les mets dans des fonctions séparées, çà fonctionne plus... Logic, çà se détruit (du moins si ma logic est bonne).

Y aurait-il moyen de faire une déclaration globale pour éviter que les destructeurs entrent en action ?

[Geolem]

Bon, j'ai résolu le problème en envoyant comme paramètre dans mes fonction d'affichage et d'encodage, l'adresse de la structure...

Dans mon main();

Code :

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

1
2
3
msgs.encMessage(msgs);
msgs.encMessage(msgs);
msgs.affMessage(msgs);

Le tour est joué.