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 }