Discussion:Programmation C++/Les classes/Exercices de développement

A propos des opérateurs de flux d'entrée/sortie

Il est écrit :

La notation A<<cout
   * On peut attacher l'opérateur de << à la classe Point comme dans l'exemple 3.
   * Certains préfèrent toutefois écrire de manière plus usuelle : cout<<A;
   * Ils arguments parfois en disant qu'en plus cela permet d'enchaîner les affichages en écrivant : cout<<A<<endl<<B;
   * Il faudrait donc normalement définir une méthode operator<<(const Point &A) sur la classe ostream.
   * Or la classe ostream est déjà écrite !

La classe ostream est déjà écrite, certes, mais rien n'empèche de surcharger un opérateur.

Une notation correcte, qui concerverait le principe d'encapsulation et la notation habituelle ("cout << A") pourrait être écrite comme cela :

class Objet
{
...
public :
//Méthode affiche
ostream& Affiche( ostream & o ) const
{
  o << "blablabla" ;
  return o;
}
};

//définition de l'opérateur << à l'exterieur de la classe, qui fait appel à la méthode Affiche() de la class Objet.
ostream& operator << (ostream & o, const Objet & O )
{
  return O.Affiche(o);
}

Un autre avantage de cette notation est dans le cas de l'héritage. Au moment de la définition d'une méthode d'affichage d'une classe fille, il n'y aura qu'a appeler la méthode 'Affiche' de la classe mère.

Exemple :

classe Fille : public Objet
{
...
public :
ostream& Affiche( ostream & o ) const
{
  Objet::Affiche() ; // appel de la méthode Affiche de la classe mère
  o << std::endl ;
  o << "Reblablabla" ;
  return o;
}
};

ostream& operator << (ostream & o, const Fille & F )
{
  return F.Affiche(o);
}

Ainsi, cout << F ; produirait à l'affichage :

blablabla
Reblablabla