请看如下一段代码：
class A {
public:
A () { pValue = new int[100]; printf("Constructor of A/n"); }
~A () { delete [] pValue; printf("Deconstructor of A/n"); }
private:
int * pValue;
};
class B {
public:
~B () { printf("Deconstructor of B/n"); }
};
class C : public B {
public:
~C () { printf("Deconstructor of C/n"); }
private:
A a;
};
int main(int argc, char* argv[])
{
C c;
return 0;
}
类C从类B中继承出来，类C中聚合了一个类A的对象，类C的析构函数并未调用类A的析构函数，请问：这段代码执行后，会调用类A的析构函数释放内存吗？经测试，执行结果如下：
Constructor of A
Deconstructor of C
Deconstructor of A
Deconstructor of B
由此可以看出，C的析构函数确实调用了类A的析构函数，该调用是由编译器隐含加入的，随后还调用了基类B的析构函数，但是请注意，编译器只会为基类和聚合类添加对析构函数的调用，如果C中的成员为指向类A的指针，则编译器不会加入对类A的析构函数的调用。即如果上面C类的成员变量是对象指针A* a，不管是构造C类对象，还是析构C类对象时，即不会构造A类对象，也不会析构A类对象。
那么，如果我们把main函数改变一下：
int main(int argc, char* argv[])
{
B * b = new C;
delete b;
return 0;
}
请问：这段代码会发生内存泄漏吗？执行结果如下：
Constructor of A
Deconstructor of B
发生了什么？调用了A的构成函数分配了内存，却只调用了B的析构函数，C和A的析构函数都没有调用，内存没有释放，为什么？
有人也许已经看出了问题所在，B和C的析构函数都应该是虚函数，否则，由于b的类型为指向类B的指针，delete b只会调用B的析构函数。当B和C的析构函数都是虚函数时，编译器会根据b指向的对象实际上是C的对象，而去调用C的析构函数。请对代码作如下改变：
class B {
public:
virtual ~B () { printf("Deconstructor of B/n"); }
};
class C : public B {
public:
virtual ~C () { printf("Deconstructor of C/n"); } //因为C类的基类B类的析构函数是虚函数，所以这里即使不表明是 virtual，系统也会将它看作是virtual的。即等价于 ~C( )，可以参看虚函数这片文章。
private:
A a;
};
再次运行，结果正确：
Constructor of A
Deconstructor of C
Deconstructor of A
Deconstructor of B
当然，为了更加简洁和清晰，我们可以对上面的一系列代码做如下修改：
头文件中的内容如下：
#include "stdafx.h"
#include <iostream>
;using namespace std;
class A
{
public:
A()
{
cout<<"class A constructing"<<endl;
}
public:
~A()
{
cout<<"class A destructing"<<endl;
}
};
class B
{
public:
B()
{
cout<<"class B constructing"<<endl;
}
public:
virtual ~B()
{
cout<<"class B Destructing"<<endl;
}
};
class C : public B
{
public:
C()
{
cout<<"class C constructing"<<endl;
}
public:
~C() //析构函数不是virtual函数，但系统仍会将它认做virtual的析构函数，即这里和virtual ~C( )是等价的。
{
cout<<"class C destructing"<<endl;
}
private:
A a;
};
(1)若主函数为：
int _tmain(int argc, _TCHAR* argv[])
{
C c;
return 0;
}
则运行结果为：
class B construcing
class A construcing
class C construcing
class C destructing
class A destructing
class B destructing
B类的析构函数是虚函数，实际上这里即使B类的析构函数不是虚函数，结果仍然是一样的。
(2)若主函数为：
int _tmain(int argc, _TCHAR* argv[])
{
B* b=new C;
delete b;
return 0;
}
则运行结果仍然为：
class B construcing
class A construcing
class C construcing
class C destructing
class A destructing
class B destructing
(3)若将上面的头文件中C类的成员变量改为
A* a; 即成员不在是A类对象，而是A类对象的指针了。
而主函数仍为(2)的主函数
则运行结果为：
class B construcing
class C construcing
class C destructing
class B destructing
也就是说，这时候不管构造C类对象，还是析构C类对象时，都不关A类对象的事了。
小结：这虽然是个小例子，但是在实际编程中，这个小例子还是有一定的应用价值的。