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.
		*/
	}
}