经典问题解析一

关于 const 的疑问

const 什么时候为只读变量？什么时候为常量？

const 常量的判别标准

只有用字面量初始化的 const 常量才会进入符号表 (const 引用除外)

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

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

在编译期间不能直接确定初始值的 const 标识符，都被作为只读变量处理 

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

• 相同：初始化变量为只读变量
• 不同：生产一个新的只读变量

const 经典问题分析

#include 

int main()
{
    const int x = 1;
    const int& rx = x;
    
    int& nrx = const_cast(rx);
    
    nrx = 5;
    
    printf("x = %d\n", x);
    printf("rx = %d\n", rx);
    printf("nrx = %d\n", nrx);
    printf("&x = %p\n", &x);
    printf("&rx = %p\n", &rx);
    printf("&nrx = %p\n", &nrx);
    
    volatile const int y = 2;
    int* p = const_cast(&y);
    
    *p = 6;
    
    printf("y = %d\n", y);
    printf("p = %p\n", p);
    
    const int z = y;
    
    p = const_cast(&z);
    
    *p = 7;
    
    printf("z = %d\n", z);
    printf("p = %p\n", p);
    
    char c = 'c';
    char& rc = c;
    const int& trc = c;
    
    rc = 'a';
    
    printf("c = %c\n", c);
    printf("rc = %c\n", rc);
    printf("trc = %c\n", trc);
    
    return 0;
}

第 5 行，用字面量初始化 const 常量 x，x 的值会进入符号表，出现 x 的地方，编译器直接用 1 来替换 (x 被引用或取地址除外，这种情况编译器会为 x 分配内存空间，但 x 不会使用这个内存空间)

第 6 行，常量 x 被引用，编译器会为 x 分配内存空间，但 x 不会使用这个内存空间，所以 x 的值还是为 1

第 19 行，被 volatile 修饰的 const 常量 y 不会进入符号表

第 27 行，用只读变量初始化 const 常量 z，z 是只读变量

第 38 行，const 引用的类型和初始化变量的类型不同，编译器会为 c 生成一个新的变量，新的变量的值和 c 一样，为 'c'， trc 引用的不是 c，而是新的变量

关于引用的疑问

引用与指针有什么关系？如何理解 "引用的本质就是指针常量"？

指针是一个变量

• 值为一个内存地址，不需要初始化，可以保存不同的地址
• 通过指针可以访问对应内存地址中的值
• 指针可以被 const 修饰成常量或者只读变量

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

• 对引用的操作 (赋值，取地址等) 都会传递到代表的变量上
• const 引用使其代表的变量具有只读属性
• 引用必须在定义时被初始化，之后无法代表其他变量

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

• 引用与指针没有任何的关系
• 引用是变量的新名字，操作引用就是操作对应的变量

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

• 为了支持新概念 "引用" 必须要有一个有效的解决方案
• 在编译器内部，使用指针常量来实现 "引用"
• 因此，"引用" 在定义时必须初始化

在工程项目开发中

• 当进行 C++ 编程时，直接站在使用的角度看待引用，与指针毫无关系，引用就是变量的别名
• 当对 C++ 代码进行调试分析时，一些特殊情况，可以考虑站在 C++ 编译器的角度看待引用

 

引用典型问题分析

#include 

int a = 1;

struct SV
{
    int& x;
    int& y;
    int& z;
};

int main()
{
    int b = 2;
    int* pc = new int(3);
    SV sv = {a, b, *pc};
    int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4

    printf("&sv.x = %p\n", &sv.x);
    printf("&sv.y = %p\n", &sv.y);
    printf("&sv.z = %p\n", &sv.z);

    delete pc;

    return 0;
}

对上面的代码进行编译，直接报错

第 17 行，我们定义了数组的引用，在 C 中，数组的每个元素的地址必须是连续的，而我们定义的数组的引用，每个元素的地址都不是连续的。 C++ 为了兼容 C，也有这样的规定，所以 C++ 就直接不支持数组的引用 

小结

指针是一个变量

引用是一个变量的新名字

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

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

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