14   Classes C++

//=========================
class  PileE {
 private :
   vector<int> Tab;
   int NbElem;       //  nb d'éléments dans la pile 
 public :
   PileE(int Max);
   void Empiler (int val);
   int Tete();
   void Depiler();
   int EstVide();
};
//=========================

void PileE::Empiler(int val);
int  PileE::Tete();
void PileE::Depiler();
int  PileE::EstVide();

//=========================
void PileE::Empiler(int val) {
if (NbElem >= Tab.size()) 
    { cout << "Erreur !" << endl; exit(1);}
Tab[NbElem]=val;
NbElem++;}

void PileE::Depiler() {
if (NbElem==0) 
    {cout << "Erreur !" << endl; exit(1);}
NbElem--;}

int PileE::Tete() {
if (NbElem==0) 
    {cout << "Erreur !" << endl; exit(1);}
return Tab[NbElem-1];}
  
int PileE::EstVide()
{return (NbElem == 0);}
//=========================

//=========================
int main() {
int i,v;
PileE P(100);  // appel du constructeur avec 100 comme argument

for (i=0;i<20;i++) {
  cin >> v;
  P.Empiler(v);
  }
while (! P.EstVide()) {
  cout << P.Tete();
  P.Depiler();
  }
}
//=========================

//=========================
PileE::PileE(int Max)
{   Tab = vector<int>(Max);
    NbElem = 0; }
//=========================

14.1   Champs et méthodes

//=========================
class  MaClasse {
 private :
    // definition de champs et methodes prives:

    type Nom-de-champ;
    type Nom-de-fct (liste parametres);
    type Nom-de-fct (liste parametres) { corps }
 
 public :
    // definition des constructeurs:
    MaClasse(liste parametres1);
    MaClasse(liste parametres2) {corps}

    // definition de champs et methodes publics:
    type Nom-de-champ;
    type Nom-de-fct (liste parametres);
    type Nom-de-fct (liste parametres) { corps }
};
//=========================

• · Un champ ou une méthode peut être private ou public. Une méthode privée ne peut être appelée que depuis une autre méthode de la classe ⁸.
  
  
  
  
  
• · La définition (le corps) des méthodes peut se faire directement dans la définition de la classe. On réserve cela aux fonctions membres très simples. En général, Il est préférable de déclarer la méthode dans la classe puis de la définir à l'extérieur avec une définition de la forme :

  type MaClasse::Nom-de-fct (liste parametres)
  { corps }
  

14.2   Constructeurs et destructeurs

• · Les constructeurs sont des méthodes particulières appelées automatiquement à chaque définition d'un objet de la classe, c'est-à-dire à chaque fois que de la mémoire est allouée pour stocker un élément de la classe. Si il existe plusieurs constructeurs, ils doivent avoir une liste de paramètres différents ⁹.
  
  
  
  
  
• · Comment passer des arguments à un constructeur ? Il suffit de faire suivre le nom de la variable (au sens large) par la liste des arguments : ``MaClasse A(i,f);'' définit une variable A et appelle le constructeur à deux arguments compatible avec les types de i et f. Si un tel constructeur n'existe pas, il y aura une erreur à la compilation. Lorsqu'aucun argument n'est donné, le constructeur sans argument est appelé.
  
  
  
  
  
• ·  * Lorsqu'aucun constructeur n'est défini explicitement, le compilateur crée un constructeur sans argument MaClasse::MaClasse() qui se contente d'appeler les constructeurs (sans argument) de chaque champ de l'objet. Mais il suffit d'avoir défini un seul constructeur pour que le constructeur sans argument ne soit pas créé automatiquement, il faut alors le définir explicitement pour pouvoir définir des variables sans donner de paramètres. Par exemple, dans notre exemple de pile, il n'est pas possible d'écrire ``PileE P;'', car il n'existe pas de constructeur ``PileE::PileE()''. Il serait facile de résoudre ce point en adaptant ``PileE::PileE(int Max)'' en donnant une valeur par défaut à Max.
  
  
  
  
  
• ·  ** Il existe un constructeur particulier appelé ``constructeur copieur'' de la forme ¹⁰ MaClasse (const MaClasse &) qui est utilisé pour le passage des paramètres et les initialisations :
  
  
  • 
    Lorsqu'une fonction a un paramètre A du type MaClasse, un appel de cette fonction avec une variable V de MaClasse conduit à l'initialisation de A avec V via le constructeur copieur.
    
    
    
  • Lorsqu'on définit une variable V et qu'on l'initialise avec une valeur E, par l'instruction ``MaClasse V=E;'', le processus sous-jacent est différent de celui mis en oeuvre lorsque l'on définit V (``MaClasse V;'') et qu'ensuite on lui affecte la valeur E (``V=E;'') : le premier cas consiste en une initialisation et à l'appel du constructeur copieur, le second cas consiste en une affectation et un appel de l'opérateur = (voir section 15)... Ça peut paraître curieux mais c'est comme ça ! Ce genre de subtilité peut être oublié en première lecture car...
    
  
  Le constructeur copieur créé par défaut se contente de faire une initialisation champ à champ avec les valeurs des champs de la variable donnée en argument. Ça tombe bien, c'est en général ce qu'il nous faut...
  
  
  
  
  
• ·  * De même qu'il existe des constructeurs mis en oeuvre pour la création de nouveaux objets, il est possible de définir un (et un seul) destructeur qui est appelé automatiquement lorsqu'une variable locale est détruite (par exemple à la fin d'une fonction). Les destructeurs sont surtout utiles lorsqu'on manipule des structures de données dynamiques (section 19).

14.3   Fonctions amies **

class C {
   ...
  friend type-de-F F(param-de-F);
  friend class C2;
   ...
};

14.4   Conversions entre types **

class fraction {
private :
   int num, den;
public :
   ...
   fraction(int v) 
     {num=v;den=1;}
   double()
     {return double(num)/den;} 
};