C++中初始化列表的使用（总结）

 1 #include <stdio.h>
 2 
 3 class Test
 4 {
 5 private:
 6     const int ci;  // const 作用于 C++ 中的成员变量后得到的是只读成员变量，只读成员变量是不可以出现在成员符号左边的；所以会出现第 10 行的错误信息；
 7 public:
 8 /*
 9     Test()  // 在这里编译器显示：ci 是一个 const 成员，没有进行初始化；因此如果要初始化 ci 成员变量，必须要在这一行进行，这个时候就让初始化列表出厂了；
10     {       
11         ci = 10;  // 在这里编译器显示：ci 在这个类中是一个只读的成员变量；
12     }
13 */
14 
15     /* 由上面的语句改换如下 */
16     Test() : ci(10)  // ci 在初始化之后可以改变，因为 ci 在这里只是一个只读的成员变量，仅仅是不能出现在赋值符号左边而已；我们依旧可以通过指针的方式来修改 ci 里面的值；
17     {
18         // ci = 10;
19     }
20        
21     int getCI() 
22     { 
23         return ci; 
24     }
25 };
26 
27 int main()
28 {
29     Test t;  // 当这里没有手工定义上面程序中的无参构造函数的时候，显示有“未初始化的 const 的成员”的错误； 同时的当这里没有通过类来定义对象的时候，可以通过编译，说明 const 可以修饰 C++ 中的成员变量；
30     
31     printf("t.ci = %d\n", t.getCI());
32     
33     return 0;
34 }

1 ClassName::ClassName() : m1(v1), m2(v1, v2), m3(v3)  // 用 v1, (v1, v2), v3 分别对 m1, m2, m3 初始化； 
2 {
3        // some other initialize operation；
4 }

 1 #include <stdio.h>
 2 
 3 class Value
 4 {
 5 private:
 6      // int mi = 0;  // 要初始化成员变量，只能使用初始化列表；在构造函 数当中的那是对成员变量赋值，不是初始化；  
 7  
 8       int mi;
 9     
10 public:
11     Value(int i)
12     {
13         printf("i = %d\n", i);
14         mi = i;
15     }
16     
17     int getI()
18     {
19         return mi;
20     }
21 };
22 
23 class Test
24 { 
25 private:
26 /*
27     Value m2(2);  // 这种明确的调用一个参数的方式也是有语法错误的；
28     Value m3(3);
29     Value m1(1);
30 */  
31     Value m2;
32     Value m3;
33     Value m1;
34     
35 public:
36 /*
37     Test()  // 这里编译器显示没有 value 类的无参构造函数来匹配调用；
38     {
39     
40     }
41 */
42     Test() : m1(1), m2(2), m3(3)  // 成员变量的初始化必须通过初始化列表来完成；
43     {
44         printf("Test::Test()\n");  // 初始化列表先于构造函数的函数体执行；
45     }
46 };
47 
48 int main()
49 {
50     Test t;
51     
52     return 0;
53 }

 1 #include <stdio.h>
 2 
 3 class Value
 4 {
 5 private:
 6     int mi;
 7 public:
 8     Value(int i)
 9     {
10         printf("i = %d\n", i);
11         mi = i;
12     }
13     int getI()
14     {
15         return mi;
16     }
17 };
18 
19 class Test
20 {
21 private:
22     const int ci;
23     
24     Value m2;
25     Value m3;
26     Value m1;
27     
28 public:
29     Test() : m1(1), m2(2), m3(3), ci(100)
30     {
31         printf("Test::Test()\n");
32     }
33     
34     int getCI()
35     {
36         return ci;
37     }
38     
39     int setCI(int v)
40     {
41         int* p = const_cast<int*>(&ci);  // 通过指针来操作常量对象；
42         
43         *p = v;
44     }
45 };
46 
47 
48 int main()
49 {
50     Test t;
51     
52     printf("t.ci = %d\n", t.getCI());
53     
54     t.setCI(10);
55     
56     printf("t.ci = %d\n", t.getCI());
57     
58     return 0;
59 }

1 int main()
2 {
3     int i = 0;  // 这是初始化，初始化的时候 i 还不存在；
4     // ...
5     i = 0;  // 这是赋值， i 是实际存在的了，并且 i 已经有一个值了，这个时候将 i 的值被改变了
6 }