Constructeurs et destructeurs

Décembre 2016

Constructeurs et destructeurs

Pour créer une instance de classe (un objet), le programme a besoin d’une fonction C++ spécifique nommée constructeur qui ne renvoie aucune valeur mais peut se charger d’initialiser les variables membres. Si vous ne la créez pas explicitement, le compilateur s’en charge. À l’inverse, quand le programme se termine, il doit faire appel à une autre fonction C++ particulière pour libérer les ressources occupées par l’objet : le destructeur. Celui-ci est aussi créé par défaut si vous ne l’avez pas inclus dans votre déclaration de classe. Le constructeur prend le nom de la classe (Date() dans notre exemple) et le destructeur le nom de la classe, précédé d’un tilde (~Date()).

À savoir

Si vous créez un constructeur pour un type de données, créez aussi le destructeur associé. Ces deux fonctions ont ceci de particulier qu’elles ne renvoient aucune valeur, pas même de type void.

Dans le programme qui suit, nous avons ajouté un constructeur qui initialise les données membres de Date et un destructeur. Les parties nouvelles sont représentées en caractères gras.

Code 4.2 : constructeur et destructeur
#include<iostream>      //Pour les entrées/sorties    
#include<string>        //Pour les chaînes    
using namespace std;     

class Date              //Définition du nouveau type Date    
{    
   int jour,annee;            //Les données membres    
   string mois;               //privées par défaut    

public:                                                   //partie publique    
      Date(int,string,int);               //Constructeur     
      ~Date();                                          //Destructeur     
      void DefinirDate(int,string,int);       //méthode d’accès    
      void LireDate() const;                    //méthode d’accès    

};    

/****Définition du constructeur****/     
Date::Date(int jourInitial,string moisInitial,int anneeInitial)     
{     
   jour=jourInitial;      //Initialisation des données membres     
   mois=moisInitial;     
   annee=anneeInitial;     
}     

/****Définition du destructeur****/     
Date::~Date()         //pas d’argument ni de valeur retournée     
{ }     

void Date::DefinirDate(int j,string m,int a)    
{ jour=j;  mois=m;  annee=a; }    

void Date::LireDate() const    
{    
 cout << "Date: " << jour << " " << mois << " " << annee ;    
}    

int main()                      //Fonction principale    
{    
  int j,a;    
  string m;     
  cout << "Saisissez la date (ex:5 novembre 2009): ";     
  cin >> j;     
  cin >> m;     
  cin >> a;     
  Date Date_du_jour(j,m,a); //création d’une instance de classe    
  Date_du_jour.LireDate(); //On affiche la valeur des données membres    
}  


Voici le résultat de l’exécution du programme :

Saisissez la date (ex:5 décembre 2010): 10 septembre 2010    
Date: 10 septembre 2010 


Dans ce programme, nous créons toujours l’instance de classe Date_du_jour mais nous initialisons ses données membres dans le constructeur. Nous avons aussi ajouté le mot clé const dans le prototype de la méthode d’accès LireDate(). En effet, cette fonction a un simple rôle consultatif, elle ne doit pas modifier de donnée membre. En la déclarant comme constante, vous interdisez à cette fonction toute opération de modification des autres membres de la classe.

À savoir

Quand une fonction ne doit pas effectuer de mise à jour de variable, déclarez-la comme constante aussi souvent que possible. Cela vous permet de repérer une action de mise à jour illégale de cette fonction dès la compilation.

Surcharge des constructeurs

Il est souvent intéressant d’offrir plusieurs méthodes pour initialiser un objet de classe en créant plusieurs constructeurs.
Nous pourrions modifier notre classe Date de la façon suivante :

Code 4.3 : classe Date avec plusieurs constructeurs
class Date {    
   int jour,annee;           //Les données membres    
   string mois;              //privées par défaut    
       
public:                        //partie publique    
      Date(int,string,int);    //jour, mois, année     
      Date(int,string);        //jour, mois, année courante     
      Date(int);               //jour, mois et année courants     
      Date();                  //date courante par défaut     
      ~Date();                 //Destructeur    
      void DefinirDate(int,string,int); //méthode d’accès    
      void LireDate() const ;           //méthode d’accès    
       
};  


Les constructeurs sont des fonctions, et en tant que tels ils obéissent aux mêmes règles de surcharge.

Le compilateur va choisir le constructeur approprié en fonction des arguments fournis :

Date Aujourdhui();            //la date courante    
Date Cette_annee(5,"mai");    //5 mai de l’année courante    
Date Date_dans_mois(10); //le 10 du mois et année courants


Le texte original de cette fiche pratique est extrait de
«Tout sur le C++» (Christine EBERHARDT, Collection
CommentCaMarche.net, Dunod, 2009)

A voir également :

Ce document intitulé «  Constructeurs et destructeurs  » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.