1、关于const的疑问

const什么时候为只读变量，什么时候是常量

const常量的判别准则：

• 只有用字面量初始化的cosnt常量才会进入符号表
• 使用其它变量初始化的const常量仍然是只读变量
• 被voliatile修饰的cosnt常量不会进入符号表

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

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

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

#include <stdio.h>

int main()
{
    const int x = 1;    // 字面量初始化，常量
    const int& rx = x;    // rx代表只读变量，编译器会为常量x分配一个空间，但是不会被使用，通过别名rx后，可以使用这个空间
    
    int& nrx = const_cast<int&>(rx); // 消除只读变量的只读属性，nrx代表的空间和rx是同一段，只不过nrx没有只读属性，是一个普通变量
    
    nrx = 5;
    
    rx = 10;
    
    printf("x = %dn", x);
    printf("rx = %dn", rx);
    printf("nrx = %dn", nrx);
    printf("&x = %pn", &x);
    printf("&rx = %pn", &rx);
    printf("&nrx = %pn", &nrx);
    
    volatile const int y = 2;        // 用了volatile后，y就不是一个常量了，是一个只读变量
    int* p = const_cast<int*>(&y);    // 指针指向y的内存空间
    
    *p = 6;
    
    printf("y = %dn", y);
    printf("p = %pn", p);        // 如果改变了y，则说明不是一个常量，没有放进符号表中
    
    const int z = y;    // 这也是一个只读变量
    
    p = const_cast<int*>(&z);
    
    *p = 7;
    
    printf("z = %dn", z);
    printf("p = %pn", p);
  
    // 不同类型的变量初始化const标识符
    char c = 'c';        
    char& rc = c;
    const int& trc = c;    // 用char型去初始化cosnt int&
    // 初始化类型不同的话，将得到一个新的只读变量
    
    rc = 'a';    // 改变rc和 trc就没关系了

    printf("c = %cn", c);
    printf("rc = %cn", rc);
    printf("trc = %cn", trc);
    
    return 0;
}

2、关于引用的疑问

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

指针是一个变量：

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

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

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

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

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

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

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

在工程项目开发中：

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

#include <stdio.h>

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};     // 结构体里面的每个元素是一个引用 ok
    int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4
    // 数组的每个元素是引用，每个元素的地址都是独立的，并不连续，err
    // C语言有一个特性，数组地址连续，地址递增
    // 引用数组会破坏这个特性，所以C++不支持引用数组
    
    printf("&sv.x = %pn", &sv.x);
    printf("&sv.y = %pn", &sv.y);
    printf("&sv.z = %pn", &sv.z);
    
    delete pc;
    
    return 0;
}

3、小结

指针是一个变量

引用是一个变量的新名字

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

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

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