Discussion :

[DLOYAS]

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

Code :

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

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++

[Invité]

Bonjour, et bonne année 2015 !

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 :

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

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

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 :

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

  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 :

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

  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 à

pourquoi la déclarer toujours amie!

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

Code :

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

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 :

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 :

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

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 :

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

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 :

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

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

[DLOYAS]

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 ?

[jo_link_noir]

std::end ; std::endl

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

[Invité]

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.