构造函数和析构函数的顺序问题

构造函数的顺序

• 先定义的先构造
• 后定义的后构造

因为对象一般都是定义在栈区的
而栈帧和栈里面的对象都要符合后进先出的性质
也就是后定义的先销毁

class A
{
public:
	//默认构造函数
	A(int x=1)
	{
		cout << "A(int x =" << x <<")" << endl;
		_x = x;	
	}
	//析构函数
	~A()
	{
		cout << "~A(" << _x << ")" << endl;
	}
private:
	int _x;
};
int main()
{
	A a1(1);
	A a2(2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

如果存在static对象（全局）

构造

1. 全局的对象最先构造
2. 局部对象从上到下依次构造

析构

1. 局部对象优先（从后往前析构）
2. 全局对象一次（从后往前析构）

因为全局对象在静态区，在所有函数之前执行，所以最先构造

而局部的static对象，存储在静态区，但是第一次执行语句的时候初始化，所以其初始化符合从上到下的顺序

而析构，是因为局部对象定义在栈区，栈区最先销毁

而全局的对象和static修饰的对象在静态区，当整个程序结束的时候才会销毁。 所以其销毁在局部对象之后

A a0(0);
int main()
{
	static A a1(1);
	A a2(2);
	A a3(3);
	static A a4(4);

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11

注意

对于其他区域的变量的顺序问题

定义多个变量的时候，也需要一个顺序
所以干脆就和栈的顺序保持一致了

其他情况

static A a0(0);
void f()
{
	static A a1(1);
	A a2(2);
	A a3(3);
	static A a4(4);
}
int main()
{
	f();
	f();
	return 0;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

如果对于上面这种，在函数中定义
应该注意：

1. 函数调用结束之后，局部对象销毁，但是static修饰的对象不会销毁
2. static修饰的对象指挥构造一次（初始化一次）

所以最后的结果是：
构造顺序： 0 1 2 3 4 2 3 2 3
析构顺序：3 2 3 2 4 1 0

注意：因为调用了两次f()函数，所以第一次调用之后，2和3先析构了一次