Constructeurs et destructeur d'une classe en C++

En C++, un constructeur est une fonction membre spéciale qui est automatiquement appelée lors de la création d'un objet. Un destructeur est appelé automatiquement lors de sa destruction. Ces deux mécanismes garantissent l'initialisation et le nettoyage corrects des ressources.

C++ propose trois types de constructeurs :

• Constructeur par défaut — sans paramètres
• Constructeur d'initialisation (paramétré) — avec paramètres
• Constructeur par copie — initialise un objet depuis un autre objet de même type

Constructeur par défaut

Un constructeur par défaut ne prend aucun paramètre. Il sert généralement à donner des valeurs initiales aux membres. Si aucun constructeur n'est défini, le compilateur en génère un automatiquement (corps vide).

  Exemple

#include <iostream>
using namespace std;

class Voiture {
private:
    int    Id;
    double vitesse;

public:
    Voiture() // constructeur par défaut
    {
        Id = 1;
        vitesse = 250.5;
        cout << "Constructeur par défaut appelé." << endl;
    }
};

int main()
{
    Voiture v1; // déclenche automatiquement le constructeur
    return 0;
}

Constructeur par défaut appelé.

Constructeur d'initialisation (paramétré)

On peut passer des arguments au constructeur pour initialiser l'objet avec des valeurs spécifiques dès sa création.

  Exemple 1 — corps du constructeur

Voiture(int a, double b)
{
    Id = a;
    vitesse = b;
    cout << "Constructeur paramétré appelé." << endl;
}

// Appel implicite
Voiture v1(1, 250.5);

// Appel explicite (équivalent)
Voiture v2 = Voiture(2, 140.0);

Liste d'initialisation

C++ offre une syntaxe plus concise et plus efficace : la liste d'initialisation, placée après le : dans l'en-tête du constructeur. Elle est obligatoire pour les membres const ou de type référence.

NomClasse(type a, type b) : membre1(a), membre2(b)
{
    // corps optionnel
}

  Exemple 2 — avec liste d'initialisation

#include <iostream>
using namespace std;

class Voiture {
private:
    int    Id;
    double vitesse;

public:
    Voiture(int a, double b) : Id(a), vitesse(b)
    {
        cout << "Constructeur paramétré — Id=" << Id
             << ", vitesse=" << vitesse << endl;
    }
};

int main()
{
    Voiture v1(1, 250.5);
    Voiture v2(2, 140.0);
    return 0;
}

Constructeur paramétré — Id=1, vitesse=250.5
Constructeur paramétré — Id=2, vitesse=140

Constructeur par copie

Il est automatiquement invoqué lors de :

• l'initialisation d'un objet depuis un autre : Voiture v2 = v1;
• le passage d'un objet par valeur à une fonction
• le retour d'un objet par valeur depuis une fonction

  Exemple

#include <iostream>
using namespace std;

class Voiture {
private:
    int    Id;
    double vitesse;

public:
    Voiture(int a, double b) : Id(a), vitesse(b) {}

    // constructeur par copie
    Voiture(const Voiture &v) : Id(v.Id), vitesse(v.vitesse)
    {
        cout << "Constructeur par copie appelé." << endl;
    }

    void afficher() {
        cout << "Id=" << Id << " - Vitesse=" << vitesse << endl;
    }
};

int main()
{
    Voiture v1(1, 250.5);
    Voiture v2 = v1;  // déclenche le constructeur par copie
    v2.afficher();
    return 0;
}

Constructeur par copie appelé.
Id=1 - Vitesse=250.5

Destructeur

  Exemple — libération de mémoire dynamique

#include <iostream>
#include <cstring>
using namespace std;

class Voiture {
private:
    char  *marque;
    int    Id;
    double vitesse;

public:
    Voiture(const char *m, int a, double b)
    {
        marque = new char[strlen(m) + 1];
        strcpy(marque, m);
        Id = a; vitesse = b;
    }

    ~Voiture() // destructeur
    {
        cout << "Destructeur appelé — libération de " << marque << endl;
        delete[] marque;
    }

    void afficher() {
        cout << "Id=" << Id << " Vitesse=" << vitesse
             << " Marque=" << marque << endl;
    }
};

int main()
{
    Voiture v1("BMW", 1, 250.5);
    v1.afficher();
    return 0; // le destructeur est appelé ici automatiquement
}

Id=1 Vitesse=250.5 Marque=BMW
Destructeur appelé — libération de BMW