Destructeur virtuel et cascade

**buzzkaido** · 22/06/2007, 20h44

Bonsoir,

Question à 10.000 $ :

- Soit une classe A avec un destructeur virtuel
- Soit une classe B dérivée de A avec un destructeur virtuel

Si je fais : (avec Visual Studio Express 2005)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
A* pA = new B();
delete pA;

1/ C'est bien le destructeur de B qui est appellé ?

2/ Le destructeur de A est bien appelé automatiquement aussi (destruction en cascade) ?

C'est tout bete, mais je m'arrache les cheveux sur une fuite de mémoire, alors je voudrais au moins etre sûr ça.

Merci !

**millie** · 22/06/2007, 20h48

Oui, les deux destructeurs sont appelés.

Cela dit, tu aurais pu trouver toi même en ajoutant par exemple un :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class A  {
 
 public:
   virtual ~A() {
     std::cerr<<"Destruction A"<<std::endl;
  }
};

Tu aurais vu que les deux destructeurs étaient appelés

**buzzkaido** · 22/06/2007, 20h55

Exact, j'aurais pu trouver moi-meme en faisant ce petit test....

Sauf que justement mon destructeur n'est pas appelé !!!

Je voulais juste etre sûr que je ce n'est pas la virtualité qui est en cause.

Merci pour la confirmation rapide, je vais pouvoir traquer ma fuite de mémoire

(l'étau se resserre)

PS : j'ai fait une recherchesur le forum, et j'ai trouvé aucun post simple et concis precisant cela, j'en ai aussi profité pour en créer un.

**millie** · 22/06/2007, 21h05

En tout cas, il faut toujours utiliser des destructeurs virtuels, tu aurais pu avoir des soucis sinon.

Par exemple ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
 
/*code pas bon*/
#include <iostream>
 
 
class A {
 public:
   ~A() {
       std::cerr<<"Destruction A"<<std::endl;
   }
};
 
class B : public A {
   public:
 
  ~B() {
       std::cerr<<"Destruction B"<<std::endl;
   }
 
};
 
/*passage pas par référence en plus :*/
void fonction(A a) {
 
/*appel du destructeur A*/
}
 
int main() {
 std::cerr<<"Test 1"<<std::endl;
 B b;
 fonction(b);
 
 std::cerr<<"Test 2"<<std::endl;
 A * a = new B();
 delete a; /*appel destructeur A et pas B*/
 
 std::cerr<<"Fin test"<<std::endl;
 
 /*appel des destructeurs B et A !*/
 return 0;
}