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.

Constructeur / Destructeur
Constructeur / Destructeur

L'exemple suivant montre comment l'initialisation de l'objet television :

1
/////////////////////////////////
2
// fichier ctelevision.h
3
/////////////////////////////////
4
class CTelevision {
5
private :
6
...
7
...
8
public :
9
  CTelevision() ;
10
} ; // CTelevision
11
 
12
 
13
///////////////////////////////////////
14
// fichier ctelevision.cpp
15
///////////////////////////////////////
16
#include "ctelevision.h"
17
CTelevision ::CTelevision() {
18
  this->marque = "MARQUE";
19
  this->techno = "LED" ;
20
  this->res = "4K" ;
21
  this->diagonale = 140 ;
22
  this->noSerie = 123456789 ;
23
  this->chaine = 1 ;
24
  this->volume = 10 ;
25
} // constructeur
26
 
27
/////////////////////////////////////////
28
// fichier appli.cpp
29
/////////////////////////////////////////
30
#include <iostream>
31
int main() {
32
   CTelevision *maTv ;
33
 
34
   maTv = new CTelevision() ; // appel automatique du constructeur lors de l'instanciation
35
   cout << maTv->volume << endl ; // affichage du volume
36
  delete maTv ; // destruction de l'objet
37
} // main

Destructeur d'un objet

Constructeur / Destructeur
Constructeur / Destructeur

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.

1
/////////////////////////////////
2
// fichier ctelevision.h
3
/////////////////////////////////
4
class CTelevision {
5
private :
6
   CTnt *tnt;
7
...
8
public :
9
  CTelevision();
10
  ~CTelevision();
11
} ; // CTelevision
12
 
13
 
14
///////////////////////////////////////
15
// fichier ctelevision.cpp
16
///////////////////////////////////////
17
#include "ctelevision.h"
18
CTelevision ::CTelevision() {
19
  tnt = new CTnt(); // création d'un objet faisant partie intégrante de l'objet CTelevision
20
} // constructeur
21
CTelevision ::~CTelevision() {
22
  delete tnt; // destruction d'un objet créé durant la vie d'un objet CTelevision
23
} // destructeur
24
 
25
/////////////////////////////////////////
26
// fichier appli.cpp
27
/////////////////////////////////////////
28
#include <iostream>
29
int main() {
30
   CTelevision *maTv ;
31
 
32
   maTv = new CTelevision() ; // maTv intègre un objet CTnt
33
   cout << maTv->volume << endl ; 
34
  delete maTv ; // Appel automatique du destructeur pour détruire l'objet CTnt
35
} // 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).

ExempleConstructeur 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 :

1
/////////////////////////////////
2
// fichier ctelevision.h
3
/////////////////////////////////
4
class CTelevision {
5
private :
6
   CTnt *tnt;
7
...
8
public :
9
  CTelevision();
10
  CTelevision(int noch=1, int novol=10); // valeur par défaut des paramètres
11
  ~CTelevision();
12
} ; // CTelevision
13
///////////////////////////////////////
14
// fichier ctelevision.cpp
15
///////////////////////////////////////
16
#include "ctelevision.h"
17
CTelevision ::CTelevision(int noch, int novol) { 
18
  this->marque = "MARQUE";
19
  this->techno = "LED" ;
20
  this->res = "4K" ;
21
  this->diagonale = 140 ;
22
  this->noSerie = 123456789 ;
23
  this->chaine = noch; // init de la chaîne
24
  this->volume = novol; // init du volume
25
} // constructeur
26
 
27
/////////////////////////////////////////
28
// fichier appli.cpp
29
/////////////////////////////////////////
30
#include <iostream>
31
int main() {
32
   CTelevision *maTv1, *maTv2;
33
 
34
   maTv1 = new CTelevision(6,0); // appel automatique du constructeur paramétré
35
  maTv2 = new CTelevision(4); // seul la chaîne est changée, le volume reste par défaut
36
   cout << maTv->volume << endl ;
37
  delete maTv1 ;
38
  delete maTv2 ; 
39
} // 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.

AttentionUtilisation 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émentLes 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 :

1
/////////////////////////////////
2
// fichier ctelevision.h
3
/////////////////////////////////
4
class CTelevision {
5
private :
6
   CTnt *tnt;
7
...
8
public :
9
  CTelevision();
10
  ~CTelevision();
11
...
12
} ; // CTelevision

La définition de toutes les méthodes se fera dans le fichier ctelevision.cpp :

1
/////////////////////////////////
2
// fichier ctelevision.cpp
3
/////////////////////////////////
4
#include "ctelevision.h"
5
 
6
CTelevision : :CTelevision() {
7
...
8
} // constructeur
9
 
10
CTelevision : :~CTelevision() {
11
...
12
} // destructeur