第20课 - 初始化列表的使用

1、问题

            类中是否可以定义const成员？

2、小实验

        下面的类定义是否合法？ 

                －如果合法，ci的值是什么，存储在哪里？

1. class Test()  
2. {  
3. private:  
4.     const int ci;  
5. public:  
6.     int getCI  
7.     {  
8.         return ci;  
9.     }  
10. }  

3、编程实验

类中的const成员     20-1.cpp

1. #include <stdio.h>  
2.   
3. class Test  
4. {  
5. private:  
6.     const int ci;  
7. public:  
8.     Test()  
9.     {  
10.         ci = 10;  
11.     }  
12.     int getCI()   
13.     {   
14.         return ci;   
15.     }  
16. };  
17.   
18.   
19. int main()  
20. {  
21.     Test t;  
22.       
23.     printf("t.ci = %d\n", t.getCI());  
24.       
25.     return 0;  
26. }  

    ·             

4、类成员的初始化 

                C++中提供了初始化列表对成员变量进行初始化 

                语法规则

1. ClassName::ClassName (): ml(vl), m2(vl,v2), m3(v3)  
2. {  
3.     //some other initialize operation  
4.  }   

                注意事项 

                         - 成员的初始化顺序与成员的声明顺序相同 

                         - 成员的初始化顺序与初始化列表中的位置无关 

                        －初始化列表先于构造函数的函数体执行 

5、编程实验

初始化列表的使用     20-2.cpp

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.     Value m2;  
23.     Value m3;  
24.     Value m1;  
25. public:  
26.     Test() : m1(1), m2(2), m3(3)  
27.     {  
28.         printf("Test::Test()\n");  
29.     }  
30. };  
31.   
32.   
33. int main()  
34. {  
35.     Test t;  
36.       
37.     return 0;  
38. }  

                

6、类中的const成员

                      类中的const成员会被分配空间的 

                      类中的const成员的本质是只读变量 

                      类中的const成员只能在初始化列表中指定初始值 

                                    编译器无法直接得到const成员的初始值，因此

                                    无法进入符号表成为真正意义上的常量。

7、编程实验

只读成员变量     20-3.cpp

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.     Value m2;  
24.     Value m3;  
25.     Value m1;  
26. public:  
27.     Test() : m1(1), m2(2), m3(3), ci(100)  
28.     {  
29.         printf("Test::Test()\n");  
30.     }  
31.     int getCI()  
32.     {  
33.         return ci;  
34.     }  
35.     int setCI(int v)  
36.     {  
37.         int* p = const_cast<int*>(&ci);  
38.           
39.         *p = v;  
40.     }  
41. };  
42.   
43.   
44. int main()  
45. {  
46.     Test t;  
47.       
48.     printf("t.ci = %d\n", t.getCI());  
49.       
50.     t.setCI(10);  
51.       
52.     printf("t.ci = %d\n", t.getCI());  
53.       
54.     return 0;  
55. }  

                

8、小插曲

            初始化与赋值不同 

                    －初始化：对正在创建的对象进行初值设置 

                    －赋值：对已经存在的对象进行值设置 

9、小结

            类中可以使用初始化列表对成员进行初始化 

            初始化列表先于构造函数体执行 

            类中可以定义const成员变量 

            const成员变量必须在初始化列表中指定初值 

            const成员变量为只读变量