本文共 747 字，大约阅读时间需要 2 分钟。

1. #include <iostream>  
2. using namespace std;  
3. class A{  
4. public:  
5.        A(){cout<<"Construct a"<<endl;p();}  
6.        virtual void p(){cout<<"A"<<endl;}  
7.        ~A(){cout<<"Destruct a"<<endl;p();}     
8. };  
9. class B : public A{  
10. public:  
11.        B(){cout<<"Construct b"<<endl;p();}  
12.        void p(){cout<<"B"<<endl;}  
13.        ~B(){cout<<"Destruct b"<<endl;p();}      
14. };  
15. int main()  
16. {  
17.     A *a=new B();  
18.     delete a;  
19.     getchar();  
20.     return 0;  
21. }  
22.   
23.   
24.   
25.   
26. 打印的结果是：  
27. Construct a  
28. A  
29. Construct b  
30. B  
31. Destruct a  
32. A  

一般情况下构造函数调用父类-》子类；析构函数调用子类-》父类

比如这么写

 B *a=new B(); 先  析构 B类 再析构A类 

但如果是上面那种写法

1. A *a=new B();  
2.     delete a;  

 ，结果就是 构造函数相同，析构函数只调用A，因为a的类型是A,delete a时将调用类型A的析构函数；没析构B，造成内存泄露

一般遇到这样的现象,需要将基类的析构函数定义为虚拟的.

还有一种情况是是析构函数是虚函数，结果是：析构函数调用子类-》父类，不过内部原理不一样

delete a时调用类型A的析构函数步骤如下:

转载地址：http://tgmji.baihongyu.com/