一、对象的构造顺序

对象的构造，先被创建的对象，先被构造，先调用其构造函数

class A {
private:
	int _a = 0;
public:
	//构造函数
	A(int a = 0)
	{
		_a = a;
		cout << "A(int a = 0)" << " " << _a << endl;
	}
};

int main()
{
	A a1(1);
	A a2(2);
	return 0;
}

二、对象的析构顺序

1.先被销毁的对象，先调用析构函数

2.同一域内，后创建的对象先销毁

3.先销毁局部的静态对象，再销毁全局的对象

3.全局对象和静态对象最后销毁

如下代码，对象a1、a2依次创建；接着对象a3创建；由于func函数执行完毕后，函数栈帧即被销毁，所以对象a3立即被销毁，调用析构函数；接着静态对象a4创建；main函数执行完毕后，对象a1、a2是同一域内的，后创建的对象先销毁，所以对象a2先销毁，a1后销毁，a2、a1依次调用析构函数；最后静态对象a4被销毁，调用其析构函数。

class A {
private:
	int _a = 0;
public:
	//构造函数
	A(int a = 0)
	{
		_a = a;
		cout << "A(int a = 0)" << " " << _a << endl;
	}

	//析构函数
	~A()
	{
		cout << "~A()" << " " << _a << endl;
	}
};

void func()
{
	A a3(3);
}

int main()
{
	A a1(1);
	A a2(2);
	func();
	static A a4(4);
	return 0;
}

对象a3在局部域中，函数func执行完毕后，对象即被销毁，调用析构函数；对象a1和a2在main函数中，main函数中执行完毕后，对象a1和a2被销毁，但是后创建的对象a2先被销毁，先创建的a1后被销毁；接着只剩下静态对象a4、a5和全局对象a6，局部的静态对象a4先销毁；最后剩下静态对象a5和全局对象a6，后创建的a6先销毁，先创建的a5后销毁。所以最终的调用析构函数先后顺序是a3、a2、a1、a4、a6、a5

class A {
private:
	int _a = 0;

public:
	//构造函数
	A(int a = 0)
	{
		_a = a;
		cout << "A(int a = 0)" << " " << _a << endl;
	}
	//析构函数
	~A()
	{
		cout << "~A()" << " " << _a << endl;
	}
};

static A a5(5);
A a6(6);

void func()
{
	A a3(3);
	static A a4(4);
}

int main()
{
	A a1(1);
	A a2(2);
	func();
	
	return 0;
}
//3 2 1 4 6 5