FAQ C++Consultez toutes les FAQ

Un destructeur est ce qui détruit un objet, libère la mémoire allouée dans le constructeur ou ce qui n'a pas été libéré durant la vie de l'objet.
Il porte le même nom que la classe précédé du signe ~.
Un destructeur ne prend aucun paramètre et ne renvoie aucune valeur de retour. Sa déclaration se fait de la façon suivante :

1
2
3
4
5
class MaClasse 
{ 
    // ...  
    ~MaClasse(); 
};

Le destructeur est appelé pour libérer les ressources acquises par un objet lorsque l'espace occupé par celui-ci doit être libéré :

1
2
3
4
5
class CMyClass 
{ 
public: 
    ~CMyClass();// destructeur 
};

Il est nécessaire de rendre le destructeur d'une classe de base virtuel quand celle-ci est destinée à être détruite polymorphiquement. Généralement dès qu'un objet commence à être utilisé polymorphiquement (c'est-à-dire utilisé en place d'un objet de la classe mère), il est fréquent qu'il soit stocké et manipulé via un pointeur vers sa classe mère, comme dans l'exemple suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream> 
  
// classe de base A destinée à être dérivée 
class A 
{ 
public: 
    A() { std::cout << "Constructeur de A.\n"; } 
    ~A() { std::cout << "Destructeur de A.\n"; } 
  
    virtual void PrintName() { std::cout << "Classe A.\n"; } 
}; 
  
// B hérite de A 
class B : public A 
{ 
public: 
    B() { std::cout << "Constructeur de B.\n"; } 
    ~B() { std::cout << "Destructeur de B.\n"; } 
  
    virtual void PrintName() { std::cout << "Classe B.\n"; } 
}; 
  
int main() 
{ 
    // utilisation polymorphe de B 
    A * a = new B; // construction de A et B 
    a->PrintName(); // affiche "Classe B" 
    delete a; // destruction de A mais pas de B ! 
}

1
2
3
4
Constructeur de A. 
Constructeur de B. 
Classe B. 
Destructeur de A.

1
2
3
4
5
6
7
8
class A 
{ 
public: 
    A() { std::cout << "Constructeur de A.\n"; } 
    virtual ~A() { std::cout << "Destructeur de A.\n"; } 
  
    virtual void PrintName() { std::cout << "Classe A.\n"; } 
};

Oui, il est possible d'appeler explicitement le destructeur d'une classe, bien que ce soit une pratique à proscrire. La raison en est simple : il est appelé automatiquement par le compilateur lorsque l'objet va être détruit, et ce, que vous l'ayez appelé ou non. Autrement dit, dans le code suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream> 
  
class Test 
{ 
public: 
    ~Test() { std::cout << "Destruction\n"; } 
}; 
  
int main() 
{ 
    Test t; 
    t.~Test(); // appel explicite du destructeur 
} // ici, le compilateur appelle à nouveau le destructeur

Dans l'ordre inverse de celui dans lequel ils ont été construits : le premier objet construit est le dernier détruit.

Dans l'exemple ci-dessous, le destructeur de b sera exécuté en premier, suivi du destructeur de a :

1
2
3
4
5
6
void userCode() 
{ 
    Fred a; 
    Fred b; 
    // ... 
}

Dans l'ordre inverse de celui dans lequel ils ont été construits : le premier objet construit est le dernier détruit.

Dans l'exemple ci-dessous, l'ordre des destructions est a[9], a[8], a[1], a[0] :

1
2
3
4
5
void userCode() 
{ 
    Fred a[10]; 
    // ... 
}

Surtout pas !

Car le destructeur sera appelé une deuxième fois au niveau de l'accolade fermant le bloc dans lequel l'objet a été créé. La norme C++ le garantit et vous ne pouvez rien faire pour empêcher que ça arrive ; c'est automatique. Et ça risque de vraiment très mal se passer si le destructeur d'un objet est appelé deux fois de suite.

Il suffit de limiter la durée de vie de l'objet local en le plaçant dans un bloc { ... } artificiel :

1
2
3
4
5
6
7
8
9
10
void someCode() 
{ 
    { 
        File f; 
        // ... [Ici, le fichier est encore ouvert] ... 
    } 
    //  Ici, le destructeur de f est appelé automatiquement ! 
  
    // ... [Le code ici s'exécutera après que f soit fermé]  ... 
}

Dans la plupart des cas, il est possible de limiter la durée de vie d'un objet local en le plaçant dans un bloc artificiel ({ ... }) .Si, pour une raison ou pour une autre, ce n'est pas possible, ajoutez à la classe une fonction membre qui a le même effet que le destructeur. Mais n'appelez pas le destructeur vous-même !

Dans le cas de File, par exemple, vous pourriez ajouter à la classe une fonction membre close(). Le destructeur se contenterait simplement d'appeler cette fonction. Notez que la fonction close() aura besoin de marquer l'objet File de façon à ne pas tenter de fermer le fichier s'il l'est déjà, ce qui peut se produire si close() est appelée plusieurs fois. L'une des solutions possibles est de donner à la donnée membre fileHandle_ une valeur qui n'a pas de sens, par exemple -1, et de vérifier à l'entrée de la fonction que fileHandle_ n'est pas égale à cette valeur :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class File { 
    public: 
      void close(); 
      ~File(); 
       // ... 
    private: 
      int fileHandle_;    //  fileHandle_ >= 0 seulement si le fichier est ouvert 
    }; 
  
    File::~File() 
    { 
      close(); 
    } 
  
    void File::close() 
    { 
      if (fileHandle_ >= 0) { 
         // ... [Utiliser les appels systèmes qui conviennent pour fermer le fichier] ... 
        fileHandle_ = -1; 
      } 
}

Dans la plupart des cas, NON.

À moins que vous ayez utilisé placement new, utilisez delete plutôt que d'appeler explicitement le destructeur de l'objet. Imaginez par exemple que vous ayez alloué un objet grâce à une « new expression » classique :

Fred* p = new Fred();

delete p; // p->~Fred() est appelé automatiquement

Non. Il n'est jamais nécessaire d'appeler explicitement un destructeur (sauf si l'objet a été créé avec un placement new).

Le destructeur d'une classe (il existe même si vous ne l'avez pas défini) appelle automatiquement les destructeurs des objets membres. Ces objets sont détruits dans l'ordre inverse de celui dans lequel ils apparaissent dans la déclaration de la classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Member { 
    public: 
      ~Member(); 
       // ... 
}; 
  
class Fred { 
    public: 
      ~Fred(); 
       // ... 
    private: 
      Member x_; 
      Member y_; 
      Member z_; 
}; 
  
Fred::~Fred() 
{ 
    // Le compilateur appelle automatiquement  z_.~Member() 
    // Le compilateur appelle automatiquement  y_.~Member() 
    // Le compilateur appelle automatiquement  x_.~Member() 
}

Non. Il n'est jamais nécessaire d'appeler explicitement un destructeur (sauf si l'objet a été créé avec un placement new).

Le destructeur d'une classe dérivée (il existe même si vous ne l'avez pas défini) appelle automatiquement les destructeurs des sous-objets des classes de base. Les classes de base sont détruites après les objets membres. Et dans le cas d'un héritage multiple, les classes de base directes sont détruites dans l'ordre inverse de celui dans lequel elles apparaissent dans la déclaration d'héritage.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Member { 
   public: 
      ~Member(); 
       // ... 
}; 
  
class Base { 
   public: 
      virtual ~Base();      // Un destructeur virtuel  
       // ... 
}; 
  
class Derived : public Base { 
   public: 
      ~Derived(); 
       // ... 
   private: 
      Member x_; 
}; 
  
Derived::~Derived() 
{ 
    // Le compilateur appelle automatiquement x_.~Member() 
    // Le compilateur appelle automatiquement Base::~Base() 
}