首先，我們來看一段程式碼：

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A's constructor." << endl;
	}
	~A()
	{
		cout << "A's destructor." << endl;
	}
};

class B
{
public:
	B()
	{
		cout << "B's constructor." << endl;
	}
	~B()
	{
		cout << "B's destructor." << endl;
	}
};

class C
{
private:
	B bInC;
public:
	C()
	{
		cout << "C's constructor." << endl;
	}
	~C()
	{
		cout << "C's destructor." << endl;
	}
	A aInC;
};

class D:public C
{
public:
	D()
	{
		cout << "D's constructor." << endl;
	}
	~D()
	{
		cout << "D's destructor." << endl;
	}
	A aInD;
private:
	B bInD;
};

int main(void) {
	D d;
	return 0;
}
 

B's constructor.
A's constructor.
C's constructor.
A's constructor.
B's constructor.
D's constructor.
D's destructor.
B's destructor.
A's destructor.
C's destructor.
A's destructor.
B's destructor.

（1）存在繼承關係時，先執行父類的建構函式，再執行子類的建構函式；

（2）當一個類中含有物件成員時，在啟動本類的建構函式之前，先分配物件空間，按物件成員的宣告順序執行他們各自的建構函式，再繼續執行本類的建構函式；

（3）對於非靜態的區域性物件，他們的解構函式的執行順序與建構函式相反。

在本程式中：

（1）執行main()，需要建立一個物件d，所以，需要執行D的建構函式。而D繼承自C，所以先要執行C的建構函式；

（2）而在C中存在物件成員bInC和aInC，所以，在C的建構函式執行之前，先按宣告順序執行B和A的建構函式，然後執行C的建構函式；

（3）輪到構造d了，但是D中有物件成員aInD和bInD，所以，在D的建構函式執行之前，先按宣告順序執行A和B的建構函式，最後，執行D的建構函式；

（4）以上所有物件的解構函式以與建構函式的執行順序相反的順序執行。

最終的執行結果就不言而喻了。

學無止境，共同學習。若本文所述存在錯誤或不妥之處，歡迎指正~