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() 
}