Destructeur virtuel et cascade

Version imprimable

22/06/2007, 20h44
buzzkaido

Destructeur virtuel et cascade
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:

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 !
22/06/2007, 20h48
millie
Oui, les deux destructeurs sont appelés.

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

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 ;)
22/06/2007, 20h55
buzzkaido

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.

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

Par exemple ici :

Code:

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;
}

22/06/2007, 21h29
loufoque

Citation:

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

C'est parce que tu ne suis pas le RAII.
23/06/2007, 11h23
buzzkaido

Non, la raison était une destruction recursive d'arbre un peu foireuse...

Mais c'est reglé !

Merci pour tout