子类析构时是否要调用父类的析构函数

descprition

• 构造时，先构造父类，再构造子类部分，因此父类和子类的构造函数都会被调用；
• 析构时，要分情况：
  （1）（父类析构函数不是虚函数）使用父类指针指向子类对象，析构该子类对象时，只会调用父类析构函数，因为不具多态性；代码理解：

class child:public parent{};
parent *p = new child();
delete p;   //调用父类析构函数，子类析构函数不会被调用

（2）上面存在一个问题，如果子类也分配的资源就会导致无法释放，使用虚函数可以解决上述问题。

class parent{
	virtual	~parent();
};
class child:public parent
{
	~child();
};
parent *p = new child();
delete p;   //先调用子类的析构函数，再调用父类的析构函数

（3）对于第一种非虚函数的情况，如果是用子类指针指向子类对象，那么会先调用子类析构函数，再调用父类析构函数，子类释放子类中分配的，父类分配父类中分配的。

class child:public parent{};
child*p = new child();
delete p;   //先调用子类的析构函数，再调用父类的析构函数

既然第三种方法也能够让父类和子类的资源都释放掉，为什么还需要使用virtual呢？这是为了让面向对象具有多态性，更简单的理解是方便编程，使用父类指针具有通用性，特别是大型系统开发中。

code

#include <iostream>

using namespace std;

//A是一个父类 , 析构函数不是虚函数
class A
{
public:
	 A()
	{
		cout << " A constructor" << endl;
	}
	  ~A()
	{
		cout << " A destructor" << endl;
	}
};

//B是A的子类
class B : public A
{
public:
	B()
	{
		cout << " B constructor" << endl;
	}
	~B()
	{
		cout << " B destructor" << endl;
	}
};

//C是一个父类 , 析构函数是虚函数
class C
{
public:
	C()
	{
		cout << " C constructor" << endl;
	}
	virtual ~C()
	{
		cout << " C destructor" << endl;
	}
};

//D是C的子类
class D : public C
{
public:

	D()
	{
		cout << " D constructor" << endl;
	}
	~D()
	{
		cout << " D destructor" << endl;
	}
};

int main()
{
    A *a = new B();
	delete a;
	cout << "-----------------------------"<<endl;
	B * b = new B();
	delete b;
	cout << "-----------------------------"<<endl;
	C *c = new D();
	delete c;

    return 0;
}

输出：

 A constructor
 B constructor
 A destructor
-----------------------------
 A constructor
 B constructor
 B destructor
 A destructor
-----------------------------
 C constructor
 D constructor
 D destructor
 C destructor