La surcharge de l'opérateur <<

salut,
je trouve toujours dans le corps des classes des fonctions amies pour la surcharge de l'operateur << :

Code:

friend ostream& operator<<(ostream&,const Compte&);

pourquoi retourner un « ostream » dans la fonction ?
et pourquoi utiliser la surcharge de l'opérateur alors qu'on peut utiliser un affichage simple ?
pourquoi la déclarer toujours amie!elle ne peut pas être fonction membre ?!
je sais que mes questions sont stupides,mais croyez moi ça fait même pas une semaine que je commence le c++ :calim2:

Bonjour, et bonne année 2015 ! :)

Citation:

Envoyé par DLOYAS

pourquoi retourner un « ostream » dans la fonction ?

Afin de permettre ce que l'on appelle le « chainage des appels » cf. FAQ.
Dans l'exemple suivant : std::cout << x << y;, la deuxième partie << y est possible car std::cout << x retourne le flux std::cout.
Si tu ne le retournais pas et avais un void à la place, tu ne pourrais pas enchainer les << sur la même instruction et aurais obligatoirement deux instructions :
Code:

1 2 std::cout << x; std::cout << y;
Citation:

Envoyé par DLOYAS

pourquoi utiliser la surcharge de l'opérateur alors qu'on peut utiliser un affichage simple ?

Car :
de 1) cela simplifie l'écriture. Prenons une simple structure Point :
Code:

1 2 3 struct Point { int x, y; };
à chaque fois que tu souhaites afficher un point, tu n'as pas à réécrire la même chose à chaque fois (cas simple ici, mais imagine pour un gros objet où l'affichage nécessite plusieurs lignes) :
Code:

1 2 3 4 5 6 7 8 Point p1 = {1,2}, p2 = {3,4}; std::cout << '(' << p1.x << ',' << p1.y << ')' << std::endl << '(' << p2.x << ',' << p2.y << ')' << std::endl; // contre : std::cout << p1 << std::endl << p2 << std::endl;
mais surtout de 2) imagine que ces membres soient privés... tu ne peux alors plus y accéder de cette manière de façon « publique ».
Et c'est sur ce second point que l'on va répondre à

Citation:

Envoyé par DLOYAS

pourquoi la déclarer toujours amie!

Une fonction amie d'une classe va justement pouvoir accéder à ses membres privés
Code:

1 2 3 4 5 6 7 8 9 struct Point { Point(int x_, int y_) : x(x_), y(y_) { } private: int x,y; }; friend ostream & operator << (ostream& stream, const Point & p) { return stream << '(' << p.x << ',' << p.y << ')'; }
Ici, si tu enlèves friend, tu supprimes la possibilité d'accès aux membres private (ou protected) de ta classe.

On en arrive au dernier point :

Citation:

Envoyé par DLOYAS

elle ne peut pas être fonction membre ?!

L'opérateur << lui-même : non. Si tu fais cela, cela a une toute autre signification (propre à la classe), et utilisation. Tu n'auras plus stream << ton_objet, mais ton_objet << quelque_chose. (Pour exemple la classe QVector du framework Qt qui a un opérateur << qui permet l'ajout d'un élément au tableau, mais qui n'a rien à voir avec la surcharge QDataStream & operator<<(QDataStream & out, const QVector<T> & vector) (analogue Qt).

Maintenant, tu peux parfaitement avoir une méthode de ta classe proche de :
Code:

1 2 3 4 5 struct Point { void print(std::ostream & stream) const { stream << '(' << x << ',' << y << ')'; } };
qui elle aura pleinement accès à tes membres privés, et que tu utiliseras comme ceci :
Code:

1 2 Point p(1,2); p.print(std::cout);
... ou dans l'opérateur << qui n'a alors plus besoin d'être qualifié de friend :
Code:

1 2 3 4 ostream & operator << (ostream& stream, const Point & p) { p.print(stream); return stream; }

Très bonne explication..
dans votre code vous avez utiliser std::endl et std::end pour sauter la ligne c'est quoi la différence entre les deux ?

std::end ; std::endl

C'est une faute de frappe, seul std::endl permet de faire un saut de ligne.

Effectivement c'est bien std::endl, std::end n'a pas sa place ici, désolé pour la confusion.
Correction reportée dans mon message précédent.