[C++面试]构造函数、析构函数调用顺序

构造函数、析构函数调用顺序

基于https://blog.csdn.net/zhangkaihang/article/details/7542621改进。由于原文有错，对其进行修改并增加析构函数的相关测试。

样例

#include <iostream>
#include <string>
using namespace std;

//抽象类A
class A
{
public:
	A()	{
		cout << "抽象类A的构造函数" << endl;
	}
	~A() {
		cout << "抽象类A的析构函数" << endl;
	}
	//纯虚函数fun
	virtual void fun1() = 0;
};

//普通类B
class B
{
public:
	B()
	{
		cout << "类B的构造函数" << endl;
	}
	~B()
	{
		cout << "类B的析构函数" << endl;
	}
};

//普通类C
class C
{
public:
	C()
	{
		cout << "类C的构造函数" << endl;
	}
	~C()
	{
		cout << "类C的析构函数" << endl;
	}
};

//普通类D
class D
{
public:
	D()
	{
		cout << "类D的构造函数" << endl;
	}
	~D()
	{
		cout << "类D的析构函数" << endl;
	}
};

//抽象类E
class E
{
public:
	E()
	{
		cout << "抽象类E的构造函数" << endl;
	}
	~E()
	{
		cout << "抽象类E的析构函数" << endl;
	}
	//纯虚函数fun
	virtual void fun2() = 0;
};


//普通类D
class F
{
public:
	F()
	{
		cout << "类F的构造函数" << endl;
	}
	~F()
	{
		cout << "类F的析构函数" << endl;
	}
};

//普通类D
class G
{
public:
	G()
	{
		cout << "类G的构造函数" << endl;
	}
	~G()
	{
		cout << "类G的析构函数" << endl;
	}
};

//普通类D
class H
{
public:
	H()
	{
		cout << "类H的构造函数" << endl;
	}
	~H()
	{
		cout << "类H的析构函数" << endl;
	}
};

//普通类D
class I
{
public:
	I()
	{
		cout << "类I的构造函数" << endl;
	}
	~I()
	{
		cout << "类I的析构函数" << endl;
	}
};

//普通类D
class M
{
public:
	M()
	{
		cout << "类M的构造函数" << endl;
	}
	~M()
	{
		cout << "类M的析构函数" << endl;
	}
};

class Test : public A, public B, virtual public C, virtual public D,  public E, public F
{
public:
	Test() :B(), A(), D(), C(), F(), E()
	{
		cout << "类Test的构造函数" << endl;
	}
	~Test()
	{
		cout << "类Test的析构函数" << endl;
	}
	void fun1()
	{
	}
	void fun2()
	{
	}
private:
	G g;
	static H h;
	static I i;
	static M m;
};

H Test::h;
I Test::i;

int main(int argc, char* argv[])
{
	Test test;
	return EXIT_SUCCESS;
}

测试

构造函数

类H的构造函数
类I的构造函数
类C的构造函数
类D的构造函数
抽象类A的构造函数
类B的构造函数
抽象类E的构造函数
类F的构造函数
类G的构造函数
类Test的构造函数

析构函数

类Test的析构函数
类G的析构函数
类F的析构函数
抽象类E的析构函数
类B的析构函数
抽象类A的析构函数
类D的析构函数
类C的析构函数
类I的析构函数
类H的析构函数

总结
一、先执行静态成员的构造函数，如果静态成员只是在类定义中声明了，而没有实现，是不用构造的。必须初始化后才执行其构造函数。

二、任何虚基类的构造函数按照它们被继承的顺序构造（不是初始化列表中的顺序）

三、任何非虚基类的构造函数按照它们被继承的顺序构造（不是初始化列表中的顺序）

四、任何成员对象的构造函数按照它们声明的顺序构造

五、类自己的构造函数

析构函数的调用顺序与此相反。