第12课 - 经典问题解析一

1、关于const的疑问       

        const     什么时候为只读变量？ 

                      什么时候是常量？

        const常量的判别准则 

                 - 只有用字面量初始化的const常量才会进入符号表 

                －使用其它变量初始化的const常量仍然是只读变量 

                －被volatile修饰的const常量不会进入符号表 

                                 在编译期间不能直接确定初始值的const标识符，

                                    都被作为只读变量处理。

          const引用的类型与初始化变量的类型 

                －相同：初始化变量成为只读变量 

                －不同：生成—个新的只读变量 

2、编程实验

const典型问题分析     12-1.cpp 

1. #include <stdio.h>  
2.   
3. int main()  
4. {  
5.     const int x = 1;  
6.     const int& rx = x;  
7.       
8.     int& nrx = const_cast<int&>(rx);  
9.       
10.     nrx = 5;  
11.       
12.     printf("x = %d\n", x);  
13.     printf("rx = %d\n", rx);  
14.     printf("nrx = %d\n", nrx);  
15.     printf("&x = %p\n", &x);  
16.     printf("&rx = %p\n", &rx);  
17.     printf("&nrx = %p\n", &nrx);  
18.       
19.     volatile const int y = 2;  
20.     int* p = const_cast<int*>(&y);  
21.       
22.     *p = 6;  
23.       
24.     printf("y = %d\n", y);  
25.     printf("p = %p\n", p);  
26.       
27.     const int z = y;  
28.       
29.     p = const_cast<int*>(&z);  
30.       
31.     *p = 7;  
32.       
33.     printf("z = %d\n", z);  
34.     printf("p = %p\n", p);  
35.       
36.     char c = 'c';  
37.     char& rc = c;  
38.     const int& trc = c;  
39.       
40.     rc = 'a';  
41.       
42.     printf("c = %c\n", c);  
43.     printf("rc = %c\n", rc);  
44.     printf("trc = %c\n", trc);  
45.       
46.     return 0;  
47. }  

                

引用与指针有什么关系？ 

如何理解"引用的本质就是指针常量" ? 

            指针是—个变量 

                    －值为—个内存地址，不需要初始化，可以保存不同的地址 

                    －通过指针可以访问对应内存地址中的值 

                    －指针可以被const修饰成为常量或者只读变量 

            引用只是—个变量的新名字 

                    －对引用的操作（赎值，取地址等）都会传递到代表的变量上

                     - const引用使其代表的变量具有只读属性 

                    －引用必须在定义时初始化，之后无法代表其它变量 

            从使用C++语言的角度来看 

                    －引用与指针没有任何的关系 

                    －引用是变量的新名字，操作引用就是操作对应的变量 

            从C++编译器的角度来看 

                    －为了支持新概念“引用”必须要—个有效的解决方案 

                    －在编译器内部，使用指针常量来实现“引用” 

                    －因此“引用”在定义时必须初始化

            在工程项目开发中 

                    －当进行C++编程时，直接站在使用的角度看待引用，

                                与指针毫无关系，引用就是变量的别名 

                    －当对C++代码进行调试分析时，—些特殊情况，可以

                                考虑站在 C++编译器的角度看待引用 

        下面的代码有问题吗？

1. int a= 1;   
2. int b = 2;   
3.   
4. int* pc= new int(3);   
5.   
6. int& array[] = {a, b, *pc};   

3、编程实验

引用典型问题分析     12-2.cpp 

1. #include <stdio.h>  
2.   
3. int a = 1;  
4.   
5. struct SV  
6. {  
7.     int& x;  
8.     int& y;  
9.     int& z;  
10. };  
11.   
12. int main()  
13. {  
14.     int b = 2;  
15.     int* pc = new int(3);  
16.     SV sv = {a, b, *pc};  
17.   //  int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4  
18.       
19.     printf("&sv.x = %p\n", &sv.x);  
20.     printf("&sv.y = %p\n", &sv.y);  
21.     printf("&sv.z = %p\n", &sv.z);  
22.       
23.     delete pc;  
24.       
25.     return 0;  
26. }  

test.cpp:17:16:error: declaration of ‘array’ as array of references

            

        对比地址发现为了兼容C语言所有特性，放弃引用数组

                            所以C++不支持引用数组

4、小结

            指针是—个变量 

            引用是一个变量的新名字 

            const引用能够生成新的只读变量 

            在编译器内部使用指针常量实现“引用” 

            编译时不能直接确定初始值的const标识符都是只读变量