參考測試程式碼1：

#include<iostream>
using namespace std;

class A
{
public:
        A(int iniI,int iniJ,int iniK):i(iniI),j(i),k(iniK){}

        int i;
        int j;
        int k;

};

int main(){
        A a = A(3,4,5);
        cout << a.i << endl;
        cout << a.j << endl;
        cout << a.k << endl;


}
 

初始化列表中，用被賦值3的i來賦值j，j打印出來也是3.

參考測試程式碼2：

#include<iostream>
using namespace std;

class A
{
public:
        A(int iniI,int iniJ,int iniK):j(iniJ),i(j),k(iniK){}

        int i;
        int j;
        int k;

};

int main(){
        A a = A(3,4,5);
        cout << a.i << endl;
        cout << a.j << endl;
        cout << a.k << endl;


}
 

初始化列表中先初始化j，再用j初始化i，這次就不能遂願了。

因為初始化列表對映（請允許我這樣稱呼它）形參和成員的順序並不是真實的賦值變數的順序，可以理解為只是簡單的無順序羅列。

這個大家都知道，我今天想知道的是，為什麼會這樣，什麼機制決定這個初始化列表中成員的初始化是按成員宣告的先後順序執行的。

其實本文想探討的問題就是——C++的初始化列表這個功能，是怎樣整個對映到編譯、執行過程的。

提起過程，我突然聯想到了scanf，或者說是cin，這些是可以給變數賦值的，但是這個是什麼時候完成的？當然是執行時，這個是動態的賦值了。

所以，假設初始化列表的初始化也是執行時，不用假設，其實就是，類物件就可以執行後動態生成（但是也應該有編譯時就定義好的吧？沒有嗎？main之外的全域性物件？）

那麼假如初始化列表都是執行時的事了，而類成員的順序是編譯時就確定好的，所以初始化列表對變數的初始化順序要遵循事先定義好的順序，也就是變數宣告順序！

但是,為什麼一定要遵頊這個順序呢？舉個反例：

同樣動態，我先宣告個i，再宣告個j，先cin給j賦值，再cin給i賦值行不行？順序不還是可以人為改變麼？所以動態這個理由說不通!

或許，就只是一種巧合，一種約定罷了。

“因為記憶體地址是順序來的，所以我們初始化它也順便按這個順序來吧？”——編者蒙

補充：

經過彙編除錯，因為地址順序是這樣的吧，也許，總之編譯器就先給i賦值，另一現象是，用j給i賦值，i和k初始值都不是0，j偏偏是0！！

這是一個很費解的問題，一個面試題就是這樣的，本來你認為初始化之前，j的值是亂的，一如i與k，可是它就是0，然後給i賦值0。。。

他們打了一個馬虎眼，寫了個0，但是我們都知道這個j(0)裡的0給不到i，所以說答案i是亂的。。。

但是面試官顯然對編譯器摳的過於細了，也許只是基於gcc或者g++？總之，自己實際操作後，j的野值它就是0。面試官期望的結果是這個。假如你是個傻子，答個0，也對了吧？瞎貓碰死耗子？

但是現在要探討這個機理，為什麼j就剛好是0，如果用k來初始化i，k就不是0啊，見第三種。

class A
{
public:
//兩種初始化結果一樣
//      A(int iniI,int iniJ,int iniK):j(iniJ),i(j),k(iniK){}
//別看前者沒有j(0)，因為j的預設值就是0，所以這個題的結果是i為0
//      A(int iniI,int iniJ,int iniK):j(0),i(j),k(iniK){}
//換個k試試，看是巧合還是編譯器有意優化
        A(int iniI,int iniJ,int iniK):j(iniJ),i(k),k(iniK){}

        int i;
        int j;
        int k;

};

有網友說那就是無規律可循的巧合，我就不信邪，肯定是有規律的，當時忘了這道題是怎麼說的，算沒算我錯，我就假設這個題有更高明的解釋。一定要找出來！

換個方向探索：

class A
{
public:
//額外加個變數看看有無變化
        A(int iniI,int iniJ,int iniK):j(iniJ),i(l),k(iniK),l(2){}

        int i;
        int j;
        int k;
        int l;

};

看到一個可能是規律的現象，k變0了，k是倒數第2個。

(gdb) print a.i
$1 = 3097936
(gdb) print a.j
$2 = 134513646
(gdb) print a.k
$3 = 0
(gdb) print a.l
$4 = 5636084

可能和物件有關，可能和地址有關，因為現在k的地址剛好是之前j的地址，0xbffff5f8。是這個地址特殊嗎？

(gdb) print &a.l 
$8 = (int *) 0xbffff5fc
(gdb) print &a.k
$9 = (int *) 0xbffff5f8
(gdb) print $ebp
$10 = (void *) 0xbffff618

棧底都是0xbffff618。

物件是保證高地址不超過0xbffff5fc，這個l的地址是之前k的地址，棧底對齊的。但是這也不是棧的底部，只是變數能達到的位置吧，可能被其他東西（我在main之外定義了一個非靜態的物件，這佔用了空間）佔用了更高地址（棧底地址高）。總之，就是這個0xbffff5fc地址的內容是0。還是什麼？

清除多餘物件變數的宣告，再編譯除錯：

(gdb) print &a
$1 = (A *) 0xbffff600
(gdb) print $ebp
$2 = (void *) 0xbffff618
(gdb) print &a.l
$3 = (int *) 0xbffff60c
(gdb) print &a.k
$4 = (int *) 0xbffff608
(gdb) print a.l
$5 = 5636084
(gdb) print a.k
$6 = 134514699
(gdb) print a.j
$7 = 134514160
(gdb) print a.i
$8 = 134514688

打印發現，因為沒存到地址0xbffff5fc了，所以沒“0”值了。那個地址0xbffff5fc也沒規定非得給物件的倒數第二個引數。完全是巧合，野值就是野值，你被忽悠後，自己又剛好遇到巧合，就更質疑裡邊有什麼特殊機制。其實是沒有的！！！！

好吧，我被面試的忽悠了，東方X信的C++題就是鬧著玩的！！！！！！！！！你們不是吹毛求疵，是雞蛋裡挑骨頭！！！

=====================================================================================================

還沒完：關於類物件的初始化到底算哪個階段的問題，或者說裡邊的成員變數初始化到底算哪個階段，發現一個比較有意思的事情。

同樣用上邊那種”錯誤“程式碼：

#include<iostream>
using namespace std;

class A
{
public:
        A(int iniI,int iniJ,int iniK):j(iniJ),i(j),k(iniK){}

        int i;
        int j;
        int k;

};

int main(){
        cout<<"hello"<<endl;
        A a = A(3,4,5);
        A a2 = A(3,4,5);
        cout << a.i << endl;
        cout << a2.i << endl;

}

執行：

[[email protected] cpp]# ./a.out
hello
134514699
5636084
[[email protected] cpp]# ./a.out
hello
134514699
3817460
[[email protected] cpp]# ./a.out
hello
134514699
5636084

可以看到，每次執行，用j上的“野”值給i賦值，結果都是固定的，想要不一樣必須重新編譯一次才行。（也不一定，也許是巧合，見下邊的int例子）所以說，至少這些初始化之前的值是固定的。

仔細一想，也沒什麼不可理解的，物件新申請了一片記憶體，又沒初始化，趕上什麼是什麼唄！

只是為什麼每次執行值都固定，是因為這塊區域的申請與劃分什麼的，都定在編譯階段了嗎？可以這樣理解嗎？

其實編譯器和記憶體申請這學得還是不精，這裡邊的記憶體指的是虛存麼？你不可能這個程式老能分配到固定的記憶體區域，並且那塊的值也固定吧。

這個問題是通用的，比如隨便宣告定義一個int變數，不定義，每次執行值也是一樣的。

int i不賦值一定固定嗎？

g++ initializeList.cpp 
[[email protected] cpp]# ./a.out
i:3817460
[[email protected] cpp]# ./a.out
i:3817460
[[email protected] cpp]# ./a.out
i:5636084
[[email protected] cpp]# ./a.out
i:3817460
[[email protected] cpp]# ./a.out
i:3817460

其實有例外：執行幾次，有一次值就不一樣了。多執行幾次，還有。但是類物件的成員值執行多次就不變化，這也是巧合，或者類和普通型別不一樣？

這樣一來，對編譯原理和記憶體分配這塊就更費解了。

====================================================================================================

結論：也許某些書有參考答案，有進一步的說明，比如網友推薦的Effective C++，還有編譯原理，或者自己用編譯器分解編譯過程來研究，待考察。