10.4 Exemple simple

Un premier exemple simple, où on définit une classe Point, dont les données sont privées (donc protégées) avec différentes méthodes géométriques.

#include <iostream>
using namespace std;
// classe de Point
class Point {
// donnees privees
private:
  double x,y;
// methodes public
public:
  // position
  void position(double a,double b) 
    { x=a; y=b; };
  // translation et mise a l'echelle
  void translate(double dx,double dy)
    { x+=dx; y+=dy;};
  void scale(double alpha) 
    { x*=alpha; y*=alpha; };
  // affichage
  void affiche()
    { cout<<"X="<<x<<" Y="<<y<<endl;};
};
//
int main()
{
   Point A;
   Point B;
   
   A.position(1,2); A.translate(1.0,0.0);
   A.affiche();
   B.position(0,2); B.scale(2.0);
   B.affiche();
   return 0;
}

10.4.1 version avec constructeur

Pour pouvoir initialiser une classe lors de sa déclaration, on utilise des constructeurs, qui sont des méthodes ayant le nom générique de la classe.

#include <iostream>
using namespace std;
// classe de Point
class Point {
// donnees privees
private:
  double x,y;
// methodes public
public:
  // constructeur
  Point() { x=0; y=0; };
  Point(double a,double b) { x=a; y=b;};
  Point(const Point &P) { x=P.x; y=P.y; };
  // position
  void position(double a,double b) 
    { x=a; y=b; };
  // translation et mise a l'echelle
  void translate(double dx,double dy)
    { x+=dx; y+=dy; };
  void scale(double alpha) 
    { x*=alpha; y*=alpha; };
  // affichage
  void affiche()
    { cout<<"X="<<x<<" Y="<<y<<endl;};
};
//
int main()
{
   Point A(1,2);
   Point B(A);
   A.translate(1.0,0.0); A.affiche();
   B.scale(2.0); B.affiche();
   return 0;
}

10.4.2 version avec surcharge d'opérateurs

On peut redéfinir tous les opérateurs du C pour les appliquer à une classe, et obtenir une notation plus simple.

Attention, cette opération génère des variables temporaires, qui dans certain cas peuvent rendre le code inefficace.

Avec le mécanisme friend (amis) on peut autoriser des fonctions à accéder aux données de la classe ( par exemple pour surcharger l'opérateur <<)

#include <iostream>
using namespace std;
// classe de Point
class Point {
// donnees privees
private:
  double x,y;
// methodes public
public:
  // constructeur
  Point(double a=0,double b=0) { x=a; y=b;};
  Point(const Point &P) { x=P.x; y=P.y; };
  // position
  void position(double a,double b) 
    { x=a; y=b;};
  // surcharge d'operateur: P=P1+P2
  Point operator+(const Point P) const
    { return Point(x+P.x,y+P.y); };
  // P=P1*a
  Point operator*(double a) const
    { return Point(x*a,y*a); }; 
  // affichage
  friend ostream& operator<<(ostream &s,const Point P); 
};
// fonction amie permettant l'acces aux donnees
ostream& operator<<(ostream &s,const Point P)
    { return s<<"["<<P.x<<","<<P.y<<"]"; };
//
int main()
{
   Point A(1); // initialise x=1 y=0
   Point B(1,2);
   Point C;
   C=A*2+B*4;
   cout<<"C="<<C<<endl;
   return 0;
}