Constructeur / destructeur d'un objet
Constructeur d'un objet
Lorsque vous mettez sous tension la première fois une télévision, elle dispose de paramètres par défaut.
Le volume est peut être réglé à 30% du maximum.
On peut imaginer qu'une recherche automatique des chaîne à lieu et que la première chaîne sera affichée.
On parle donc des valeurs d'initialisation de l'objet.
Le constructeur est une méthode exécutée obligatoirement lors de l'instanciation de l'objet.
Le nom de cette méthode est le nom de la classe (voir la classe ci-contre).
Dans le code du constructeur, nous pouvons initialiser notre objet avant toute utilisation, c'est à dire initialiser les attributs.
Il est également possible d'effectuer des déclarations dynamique de mémoire pour le bon fonctionnement de l'objet.
Il faudra absolument en tenir compte lors de la destruction de l'objet.
L'exemple suivant montre comment l'initialisation de l'objet television
:
/////////////////////////////////
// fichier ctelevision.h
/////////////////////////////////
class CTelevision {
private :
...
...
public :
CTelevision() ;
} ; // CTelevision
///////////////////////////////////////
// fichier ctelevision.cpp
///////////////////////////////////////
CTelevision ::CTelevision() {
this->marque = "MARQUE";
this->techno = "LED" ;
this->res = "4K" ;
this->diagonale = 140 ;
this->noSerie = 123456789 ;
this->chaine = 1 ;
this->volume = 10 ;
} // constructeur
/////////////////////////////////////////
// fichier appli.cpp
/////////////////////////////////////////
int main() {
CTelevision *maTv ;
maTv = new CTelevision() ; // appel automatique du constructeur lors de l'instanciation
cout << maTv->volume << endl ; // affichage du volume
delete maTv ; // destruction de l'objet
} // main
Destructeur d'un objet
Le destructeur est une méthode spécifique d'un objet qui porte son nom précédé du caractère tilde (voir classe ci-contre).
Le destructeur est appelé automatiquement lorsque la destruction de l'objet est demandée.
Le rôle du destructeur est libérée les zone mémoire réservée dynamiquement pendant le fonctionnement de l'objet.
Le destructeur est donc particulièrement important pour réaliser des programmes en langage objets fiables.
/////////////////////////////////
// fichier ctelevision.h
/////////////////////////////////
class CTelevision {
private :
CTnt *tnt;
...
public :
CTelevision();
~CTelevision();
} ; // CTelevision
///////////////////////////////////////
// fichier ctelevision.cpp
///////////////////////////////////////
CTelevision ::CTelevision() {
tnt = new CTnt(); // création d'un objet faisant partie intégrante de l'objet CTelevision
} // constructeur
CTelevision ::~CTelevision() {
delete tnt; // destruction d'un objet créé durant la vie d'un objet CTelevision
} // destructeur
/////////////////////////////////////////
// fichier appli.cpp
/////////////////////////////////////////
int main() {
CTelevision *maTv ;
maTv = new CTelevision() ; // maTv intègre un objet CTnt
cout << maTv->volume << endl ;
delete maTv ; // Appel automatique du destructeur pour détruire l'objet CTnt
} // main
Dans cet exemple, nous comprenons qu'un objet tnt
sera créé à l'instanciation de l'objet maTv
.
En cas de destruction de l'objet maTv
, l'objet interne tnt
sera automatiquement détruit par appel du destructeur de maTv
.
Synthèse sur les constructeurs/destructeurs
Vous notez donc que les appels au constructeur et destructeur d'un objet se font automatiquement, respectivement lors de l'instanciation et lors de la destruction de l'objet.
Si le constructeur est quasiment indispensable pour initialiser un objet, le destructeur n'est utile que pour gérer les allocations dynamiques de la mémoire effectuées durant la vie de l'objet.
Il est donc possible qu'une classe ne contienne pas de destructeur.
Constructeurs paramétrés
Ce ne sont pas toutes les télévisions qui seront de la même marque ou qui auront les mêmes caractéristiques.
Il est donc utile de pouvoir initialiser un objet avec des valeurs différentes de celles par défaut.
Cela est possible en créant un autre constructeur qui contient les paramètres d'initialisation.
Ce constructeur existera en plus du constructeur par défaut (celui qui ne contient pas de paramètres).
Exemple : Constructeur paramétré pour une chaîne et un volume différent
Imaginons que nous voulions créer un objet CTelevision
avec la chaîne réglée à 6 et le volume à 0 :
/////////////////////////////////
// fichier ctelevision.h
/////////////////////////////////
class CTelevision {
private :
CTnt *tnt;
...
public :
CTelevision();
CTelevision(int noch=1, int novol=10); // valeur par défaut des paramètres
~CTelevision();
} ; // CTelevision
///////////////////////////////////////
// fichier ctelevision.cpp
///////////////////////////////////////
CTelevision ::CTelevision(int noch, int novol) {
this->marque = "MARQUE";
this->techno = "LED" ;
this->res = "4K" ;
this->diagonale = 140 ;
this->noSerie = 123456789 ;
this->chaine = noch; // init de la chaîne
this->volume = novol; // init du volume
} // constructeur
/////////////////////////////////////////
// fichier appli.cpp
/////////////////////////////////////////
int main() {
CTelevision *maTv1, *maTv2;
maTv1 = new CTelevision(6,0); // appel automatique du constructeur paramétré
maTv2 = new CTelevision(4); // seul la chaîne est changée, le volume reste par défaut
cout << maTv->volume << endl ;
delete maTv1 ;
delete maTv2 ;
} // main
Nous avons également créé un objet maTv2
qui ne change que le numéro de la chaîne.
Cela est rendu possible par la syntaxe du C++ décrite ci-dessus.
Mémorisez que :
Le constructeur est paramétré.
Que les paramètres ont une valeur par défaut au cas ou un paramètre est manquant (cas de
maTv2
).L'utilisation du constructeur par défaut reste possible.
Attention : Utilisation directe des attributs privés de classe
Dans le code source précédent, le constructeur paramétré modifie directement les attributs de classe chaine
et volume
. C'est dangereux et donc non conseillé. Il vaut mieux utiliser les méthodes setChaine()
et setVolume()
(les créer au besoin) qui vérifieront les valeurs demandées.
Complément : Les fichiers définissant une classe
Lorsque vous développez une classe, vous devez créer 2 fichiers.
Exemple, pour la classe CTelevision
la définition des membres de la classes se fera dans ctelevision.h
:
/////////////////////////////////
// fichier ctelevision.h
/////////////////////////////////
class CTelevision {
private :
CTnt *tnt;
...
public :
CTelevision();
~CTelevision();
...
} ; // CTelevision
La définition de toutes les méthodes se fera dans le fichier ctelevision.cpp
:
/////////////////////////////////
// fichier ctelevision.cpp
/////////////////////////////////
CTelevision : :CTelevision() {
...
} // constructeur
CTelevision : :~CTelevision() {
...
} // destructeur