C++继承与组合关系中构造函数与析构函数执行顺序

/*
	测试继承与组合关系中构造函数与析构函数执行顺序
	在继承关系中：先调用基类构造函数，再调用子类构造函数
	针对包含自定义类型成员变量的情况，先构造成员变量，在调用自己的构造函数
	析构函数与构造函数调用顺序相反
*/
void Test_Constructor_Destructor_Sequence()
{
	cout << "Test_Constructor_Destructor_Sequence" << endl;
	// 测试包含继承关系和自定义成员变量的
	class A
	{
	public:
		A(){ cout << "A Constructor." << endl; }
		~A(){ cout << "A Destructor." << endl; }
	};

	class B
	{
	public:
		B(){ cout << "B Constructor." << endl; }
		~B(){ cout << "B Destructor." << endl; }
	};

	class C
	{
	public:
		C() { cout << "C Constructor." << endl; }
		~C(){ cout << "C Destructor." << endl; }
	};

	class D
	{
	public:
		D() : m_i_(0), m_b_(B()), m_a_(A()) { cout << "D Constructor 1." << endl; }
		D(int i) : m_i_(i){ cout << "D Constructor 2." << endl; }
		~D(){ cout << "D Destructor." << endl; }
	private:
		int m_i_;
		A m_a_;
		B m_b_;
	};

	class E : public D
	{
	public:
		E() : m_c_(C()), m_j(0) { cout << "E Constructor 1." << endl; }
		E(int i, int j) : D(i), m_j(j){ cout << "E Constructor 2." << endl; }
		~E(){ cout << "E Destructor." << endl; }
		E(const E& e){ cout << "E Copy Constructor." << endl; }
		E(const E&& e){ cout << "E Move Constructor." << endl; }
	private:
		int m_j;
		C m_c_;
	};

	{
		cout << "*1*" << endl;
		E e1;
		/*
		离开作用域输出结果：
			A Constructor.
			B Constructor.
			D Constructor 1.
			C Constructor.
			E Constructor 1.
			E Destructor.
			C Destructor.
			D Destructor.
			B Destructor.
			A Destructor.
		*/
	} 
	
	{
		cout << "*2*" << endl;
		E e2(1,2);
		/*离开作用域输出结果：
			A Constructor.
			B Constructor.
			D Constructor 2.
			C Constructor.
			E Constructor 2.
			E Destructor.
			C Destructor.
			D Destructor.
			B Destructor.
			A Destructor.
		*/
	}
}