Précédemment, lorsque nous faisions "Point a;" une instance (un objet) de la classe Point était créé. En cas d'oubli d'initialiser cette instance, on se retrouve avec des variables internes ne contenant que des valeurs aléatoires, ce qui peut être dangereux. Nous allons voir comment à la fois nous pouvons créer une instance et l'initialiser en même temps. Cette opération nécessite ce qu'on appelle un constructeur :
class Point
{
private:
int
x;
int
y;
public:
Point(int,
int);
// Constructeur
};
Un constructeur est une fonction membre dont le nom est identique au nom de la classe. Il peut contenir ou non des arguments, mais contrairement aux fonctions, il ne possède aucun type de retour (void, int, etc.). Voici ce que donnerait sa définition :
Point::Point(int abscisse,
int ordonnee)
{
x = abscisse;
y = ordonnee;
}
Maintenant que nous avons un constructeur qui réclame 2 arguments, il n'est plus possible d'écrire :
Point a;
Une syntaxe correcte pourrait par exemple être :
Point a(10, -2);
En résumé, le constructeur apporte une simplification (remplacement de deux lignes de code par une seule), mais surtout il accroit la sécurité dans la création d'une instance de classe en s'assurant de l'initialisation correcte les variables membres.
Rassurez vous celà ne fait pas exploser votre ordinateur.
Si le destructeur existe dans le programme, il est alors appelé au moment de la
suppression de l'instance.
Sa présence n'est pas obligatoire sauf dans le cas où la création d'une instance
nécessite l'allocation dynamique d'un espace mémoire avec l'instruction "new".
Pour faire simple le destructeur devient obligatoire si le programmeur décide
d'attribuer manuellement de la mémoire à une variable.
Dans ce cas nous utiliserons l'instruction delete dans notre destructeur afin
de libérer la mémoire devenue inutile.
Celà évite ce qu'on appelle une "fuite de mémoire".
C'est important car si cette fuite se répète en boucle durant le processus,
nous pourrions avoir un plantage du programme par manque de mémoire disponible.
Noter aussi que cette mémoire perdue ne sera réatribuée à l'ordinateur qu'à son
redémarrage.
Assez bavardé, découvrons la syntaxe d'un destructeur. Il s'écrit avec le nom de la
classe précédé d'un tildé. Il ne comporte aucun argument (parenthèses présentes mais vide),
et n'est jamais précédé d'un type (void, int, etc.).
~Point(); // Destructeur
Découvrons maintenant un exemple complet de programme utilisant un constructeur et un destructeur.
#include <iostream>
using namespace std;
// Déclaration de la classe Point
class Point
{
private:
int
x;
int
y;
public:
Point(int,
int);
// Constructeur
~Point();
// Destructeur
};
int main()
{
void
uneFonction();
// On déclare une fonction
Point a(5,
-3);
uneFonction();
Point b(0,
0);
return 0;
}
// Définitions des fonctions de la classe Point
Point::Point(int abscisse,
int ordonnee)
// Constructeur
{
cout
<<
"Creation d'un point avec le constructeur"
<<
endl;
x = abscisse;
y = ordonnee;
}
Point::~Point()
// Destructeur
{
cout
<<
"Le destructeur annonce la suppression d'un point"
<<
endl;
}
void
uneFonction()
{
Point c(1,
2);
Point d(-4,
0);
}
Lorsqu'on lance dans CodeBlocks ce programme, on obtient :
Creation d'un point avec le constructeur
Creation d'un point avec le constructeur
Creation d'un point avec le constructeur
Le destructeur annonce la suppression d'un point
Le destructeur annonce la suppression d'un point
Creation d'un point avec le constructeur
Le destructeur annonce la suppression d'un point
Le destructeur annonce la suppression d'un point
Process returned 0(0x0) execution time : 0.069 s
Press any key to continue.
Analysons le comportement :
La partie "main()" commence par declarer une fonction, sans rien faire de plus avec.
Le point "a" est ensuite créé.
La fonction est appelée ce qui crée les deux points "c" et "d".
A la sortie de cette fonction les deux points "c" et "d" sont détruits.
Le programme se poursuit dans "main()" et le point b est créé.
La sortie de "main()" entraine la destruction de "b" et de "a".