初始化列表的用法說明

類對象的構造順序是這樣的：
1.分配內存，調用構造函數時，隱式／顯示的初始化各數據成員
2.進入構造函數后在構造函數中執行一般計算

使用初始化列表有兩個原因：

1.必須這樣做：

   《C++ Primer》中提到在以下三種情況下需要使用初始化成員列表：

一、需要初始化的數據成員是對象的情況；
二、需要初始化const修飾的類成員；
三、需要初始化引用成員數據；

        如果我們有一個類成員，它本身是一個類或者是一個結構，而且這個成員它只有一個帶參數的構造函數，而沒有默認構造函數，這時要對這個類成員進行初始化，就必須調用這個類成員的帶參數的構造函數，如果沒有初始化列表，那么他將無法完成第一步，就會報錯。
class ABC
...{
public:
         ABC(int x,int y,int z);
private:
         int a;
         int b;
         int c;
};
class MyClass
...{
public:
        MyClass():abc(1,2,3)...{}
private:
        ABC abc;
};

        因為ABC有了顯示的帶參數的構造函數，那么他是無法依靠編譯器生成無參構造函數的，所以沒有三個int型數據，就無法創建ABC的對象。
        ABC類對象是MyClass的成員，想要初始化這個對象abc，那就只能用成員初始化列表，沒有其他辦法將參數傳遞給ABC類構造函數。
        另一種情況是這樣的：當類成員中含有一個const對象時，或者是一個引用時，他們也必須要通過成員初始化列表進行初始化，因為這兩種對象要在聲明后馬上初始化，而在構造函數中，做的是對他們的賦值，這樣是不被允許的。

2.效率要求這樣做：
       類對象的構造順序顯示，進入構造函數體后，進行的是計算，是對他們的賦值操作，顯然，賦值和初始化是不同的，這樣就體現出了效率差異，如果不用成員初始化類表，那么類對自己的類成員分別進行的是一次隱式的默認構造函數的調用，和一次復制操作符的調用，如果是類對象，這樣做效率就得不到保障。

注意：構造函數需要初始化的數據成員，不論是否顯示的出現在構造函數的成員初始化列表中，都會在該處完成初始化，并且初始化的順序和其在聲明時的順序是一致的，與列表的先后順序無關，所以要特別注意，保證兩者順序一致才能真正保證其效率。

為了說明清楚，假設有這樣一個類：
class foo{
   private :
    int a, b;
};
1、foo(){}和foo(int i = 0){}都被認為是默認構造函數，因為后者是默認參數。兩者不能同時出現。
2、構造函數列表的初始化方式不是按照列表的的順序，而是按照變量聲明的順序。比如foo里面，a在b之前，那么會先構造a再構造b。所以無論 foo():a(b + 1), b(2){}還是foo():b(2),a(b+1){}都不會讓a得到期望的值。如果先聲明b再聲明a則會更好。
3、構造函數列表能夠對const成員初始化。比如foo里面有一個int const c;則foo(int x) : c(x){}可以讓c值賦成x。不過需要注意的是，c必須在每個構造函數（如果有多個）都有值。
4、在繼承里面，只有初始化列表可以構造父類的private成員。比如說
class child : public foo{
}
foo里面的構造函數是這樣寫的:foo (int x) { a = x; }.
而在child里面寫child(int x){ foo(x); }是通過不了編譯的。只有把父類初始化改為foo(int x) : a(x){}而子類構造寫作child (int x) : foo(x){}才可以。

另一篇關于初始化列表的文章：

C++初始化類的成員，不但可以用構造函數（constructor）完成，而且可以用初始化類成員列表來完成。MFC大量用到此方法。例如有些初學者可能不大理解如下代碼：
class A
{
public:
    int member_var; //成員變量
    A();            //構造函數
}
A::A():member_var(0)
{
}

他們覺得這個構造函數的定義應該只能這樣寫：
A::A()
{
   member_var=1;
}

其實兩種方法都可。但是有些情況下，只能用第一種，而且通常情況下用第一種也會效率高些。

其實，第一種方法是真正的初始化(initialization),而在構造函數內實現的“=”操作其實是賦值(assign)。這兩種方法的一切區別從這兒開始。區別大概如下：

我們知道普通變量編譯器都會默認的替你初始化。他們既能初始化，也能被賦值的，而常量(const)按照其意思只能被初始化，不能賦值。否則與變量就無區別了。所以常量成員(const member)只能用成員初始化列表來完成他們的“初始化”，而不能在構造函數內為他們“賦值”。 
我們知道類的對象的初始化其實就是調用他的構造函數完成，如果沒有寫構造函數，編譯器會為你默認生成一個。如果你自定義了帶參數的構造函數，那么編譯器將不生成默認構造函數。這樣這個類的對象的初始化必須有參數。如果這樣的類的對象來做另外某個類的成員，那么為了初始化這個成員，你必須為這個類的對象的構造函數傳遞一個參數。同樣，如果你在包含它的這個類的構造函數里用“=”，其實是為這個對象“賦值”而非“初始化”它。所以一個類里的所有構造函數都是有參數的，那么這樣的類如果做為別的類的成員變量，你必須顯式的初始化它，你也是只能通過成員初始化列表來完成初始化。例如： 
class B
{
......
}

class A
{
public:
B member_b;
A();
}
A::A():B(...) //你必須顯式初始化它，因為他的所有構造函數
              //都是有參數的，之后才能被賦值。
{
B=...； //因為如上所寫，已經初始化了，才能被賦值，否則錯誤。
}


——————————————————————————————————————

初始化順序：

class test 
{

       const int a;

       std:string str;

       object o;

       test():str(“df”),o(null),a(0)

{

}    

};


×××的既是初始化列表，他們會在構造函數正式調用前被調用，且他們的初始化順序并不是根據 初始化列表中出現的順序，而是他們聲明的順序來初始化。如上：

初始化順序是：a, str, o;

一般用于初始化 常量類型，靜態類型的數據，或者不能獨立存在的數據