文章目录

• 一、引言
• 二、代码

一、引言

• 构造子类对象时，先调用父类构造函数，再调用子类构造函数（构造函数没有虚函数这一说）
• 析构子类对象时，先调用子类析构函数，再调用父类析构函数（无论父类的析构函数是否为虚函数）
• 构造子类构造的父类对象时，先调用父类构造对象，再调用子类构造对象（构造函数没有虚函数这一说）
• 析构子类构造的父类对象时，若父类是虚函数，则先调用子类析构函数，再调用父类析构函数
• 析构子类构造的父类对象时，若父类不是虚函数，则只调用父类析构函数

二、代码

#include <algorithm>
#include <iostream>
#include <fstream>

using namespace std;
fstream fout("test.txt", ios::app);
//A是一个父类 , 析构函数不是虚函数
class A
{
public:
	A()
	{
		fout << " A constructor" << endl;
	}
	~A()
	{
		fout << " A destructor" << endl;
	}
};

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

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

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

	D()
	{
		fout << " D constructor" << endl;
	}
	~D()
	{
		fout << " D destructor" << endl;
	}
};
int main()
{
	B * b = new B();//先调用父类A的构造方法,然后调用子类B的构造方法
	delete b;//删除子类,这时候会先调用子类B的析构函数,再调用父类A的析构函数
	fout << "-----------------------------" << endl << endl;
	A *a = new B();//用子类B构造一个父类A的对象 先调用父类A的构造方法,然后调用子类B的构造方法
	delete a;//删除父类,这时候由于A的析构函数不是虚函数,所以直接调用父类A的构造方法,不会调用子类B的构造方法
	fout << "-----------------------------" << endl << endl;


	D * d = new D();//先调用父类C的构造方法,然后调用子类D的构造方法
	delete d;//删除子类,这时候会先调用子类D的析构函数,再调用父类C的析构函数
	fout << "-----------------------------" << endl << endl;
	C *c = new D();//同理,先调用父类C的构造方法,然后调用子类D的构造方法
	delete c;//删除父类,这时候由于C的析构函数是虚函数,所以直接先调用子类D的析构函数,再调用父类C的析构函数

	system("pause");
	return 0;
}

运行结果：

参考：
参考1