Constructeur et destructeur

On peut définir un constructeur de classe qui sera appellée lorsque l’on instancie un nouvel objet.

struct MaClasse {
    MaClasse(void) {
        cout << "coucou" << endl;
    }
};
 
Copier

Pour éviter d’appeller le constructeur, il faut utiliser malloc (faut pas faire ça, c’est pas cohérent).
Il ne faut donc pas utiliser malloc pour utiliser l’objet avec des *, il faut utiliser new (et delete remplace free).

int main(void) {
    /* On réserve de la place, comme malloc, mais
     * là on appelle bien le constructeur */
    MaClasse* b = new MaClasse();
 
    // ...
 
    delete b;
 
    return 1;
}
 
Copier

On utilises delete car on peut aussi définir un destructeur (comportement lorsqu’on libère la classe), et free ne le permet pas.

Il y a donc plusieurs méthodes qui sont crées implicitement : constructeur, destructeur.

#include <iostream>
 
using namespace std;
 
struct Tableau {
    private:
        int taille;
        int* tab;
 
    public:    
        // Constructeur
        Tableau(int ptaille) {
            tab = new int[ptaille];
            taille = ptaille;
 
            for(int i = 0; i < taille; i++)
                tab[i] = 0;
        }
 
        void afficher(void) {        
            for(int i = 0; i < taille; i++)
                cout << ' ' << tab[i];
            cout << endl;
        }
 
        // Destructeur        
        ~Tableau(void) {
            delete[] tab;
        }
};
 
int main(void) {
    Tableau tab1(10);
    tab1.afficher();
}
 
Copier

Résumé

Le(s) constructeur(s) possède(nt) le même nom que la classe. Pour le destructeur on ajoute un ~ devant.
Exemple :

class MaClasse {
    MaClasse(...) {
        // corps du constructeur
    }
 
    ~MaClasse(...) {
        // corps du destructeur
    }
};
 
Copier

Il ne peut y avoir qu’un seul destructeur. Le destructeur ne prend jamais de paramètre. Par défaut pour toute classe un constructeur et un destructeur implicite sont générés.
Le mot clé this est une expression qui donne l’adresse de l’objet de la classe.

Les opérateurs new et delete (ainsi que new[] et delete[]) sont à utiliser sur les classes car ils appellent les constructeurs et destructeurs.
Exemple :

MaClasse* a = new MaClasse(...);
MaClasse* tab = new MaClasse[13];
 
delete a;
delete[] tab;
 
Copier

Cf. Chapitre 4 pour d’autre façon d’appeller des constructeurs (il y aussi le constructeur de recopie).