c++中的 const 关键字

知识回顾：C语言中 const

　　const 修饰的变量是 只读的，本质上还是变量；（只读变量：可以通过指针修改只读变量中的值）

　　const 修饰的局部变量在栈上分配空间；

　　const 修饰的全局变量在只读存储区分配空间；

　　const 只在编译期间生效，在运行期间无效；

　　const 修饰的变量不是真的常量，它只是告诉编译器该变量不能出现在赋值符号的左边；

#include <stdio.h>

int main()
{
    const int c = 10;   // c 是只读变量
    int* p = (int*)&c;
    
    *p = 5;
    
    printf("c = %d
", c);  // c = 5
    
    return 0;
}
// 编译器 gcc

---

---

c++ 中 const

1. const 常量

　　1）const 修饰的变量 是一个真正的常量；

　　　　这是由于c++中使用的符号表机制，当使用一个字面量初始化const变量时，就会将该字面量放入符号表中；在编译过程中，若发现使用该变量，就会将这个变量替换为符号表中值；

　　2）在编译过程中，若发生以下情况，则可能会给对应的常量分配存储空间；

　　　　1、当 const 常量为全局时，并且需要在其它文件中使用；（extern）

　　　　2、当使用 & 操作符对 const 常量取地址；

　　　    注：c++ 编译器虽然可能为 const 常量分配存储空间，但不会使用其存储空间中的值；

#include <stdio.h>

int main()
{
    const int c = 10;   // c 是常量
    int* p = (int*)&c;
    
    *p = 5;
    
    printf("c = %d
", c);  // c = 10
    
    return 0;
}

// 编译器 g++

　　　　

　　3）const 常量 与 宏定义

　　　　相同点：

　　　　　　c++中 const 常量 ≈ 宏定义；( const int a = 10; ≈ #define a 10 )

　　　　不同点：

　　　　　　const 是由编译器处理，编译器对 const 有 类型检查 和 作用域检查；

　　　　　　宏定义 是由预处理器处理，只是单纯的文本替换；

#include <stdio.h>

void f()
{
    #define a 3
    const int b = 4;
}

void g()
{
    printf("a = %d
", a);
    //printf("b = %d
", b);    // err
}

int main()
{
    const int A = 1;
    const int B = 2;
    int array[A + B] = {0};
    int i = 0;
    
    for(i=0; i<(A + B); i++)
    {
        printf("array[%d] = %d
", i, array[i]);
    }
    
    f();
    g();
    
    return 0;
}

---

　　结论：--- 经典问题解析一

　　　　1）const 常量的判断方法：

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

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

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

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

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

　　　　　　不同：生成一个新的只读变量；

#include <stdio.h>

int main()
{
    const int x = 1;    // 只有用  字面量  初始化的const常量才进入符号表--- 此处x进入符号表，x是常量
    const int& rx = x;  // 编译器分配给常量x的内存地址的别名为 rx--- rx是只读变量
    
    int& nrx = const_cast<int&>(rx);    // 去除只读变量rx的只读属性 --- nrx
    
    nrx = 5;
    
    printf("x = %d
", x);          // 1
    printf("rx = %d
", rx);        // 5
    printf("nrx = %d
", nrx);      // 5
    printf("&x = %p
", &x);        // 0x7ffd8aed8f90
    printf("&rx = %p
", &rx);      // 0x7ffd8aed8f90
    printf("&nrx = %p
", &nrx);    // 0x7ffd8aed8f90    
    
    volatile const int y = 2;       // volatile 修饰的const常量不会进入符号表---y是只读变量
    int* p = const_cast<int*>(&y);  // 去除y的只读属性
    
    *p = 6;
    
    printf("y = %d
", y);  // 6
    printf("&y = %p
", &y);// 0x7ffd8aed8f94
    printf("p = %p
", p);  // 0x7ffd8aed8f94
    
    const int z = y;    // 用 其它变量 初始化const常量，仍是只读变量 --- z是只读变量
    
    p = const_cast<int*>(&z);   // 去除z的只读属性
    
    *p = 7;
    
    printf("z = %d
", z);  // 7
    printf("&z = %p
", &z);// 0x7ffd8aed8f98
    printf("p = %p
", p);  // 0x7ffd8aed8f98
    
    char c = 'c';
    char& rc = c;
    const int& trc = c; //const引用类型 与 初始化变量的类型不一致，则生成新的只读变量 --- trc为新的只读变量

    printf("c = %c
", c);      // c
    printf("rc = %c
", rc);    // c
    printf("trc = %c
", trc);  // c
    
    rc = 'a';
    
    printf("c = %c
", c);      // a
    printf("rc = %c
", rc);    // a
    printf("trc = %c
", trc);  // c
    
    return 0;
}

　　　　3） 指针常量 Type * const pt （引用的本质）

　　　　　　c++中没有引用数组的概念；（因为数组在内存中是一段连续的存储空间，然而引用数据并不满足这个要求）

2 类中的 const（const 对象  和 const 成员函数）--- 经典问题解析二

　　const 对象的特点：

　　　　1）const修饰的对象为只读对象；

　　　　2）只读对象的成员变量不可以修改；

　　　　3）只读对象是编译阶段的概念，运行时无效；

　　　　注：const 对象 不推荐使用；

　　const 成员函数的特点：

　　　　1）只读对象只能调用const成员函数；

　　　　2）const成员函数 只能 调用const成员函数；

　　　　3）const成员函数 不能 直接修改成员变量的值；（const 成员函数 使 this指针所指向的对象具有了只读属性）

　　　　注：const 成员函数 在 声明与定义的时候必须都有 const；

#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i);
    Test(const Test& t);
    int getMi() const;
    void print();
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{
    
}
    
int Test::getMi() const
{
    //mi = 0; // error // const成员函数 不能 直接修改成员变量的值
    //print();// error // const成员函数 只能 调用const成员函数
    return mi;
}

void Test::print()
{
    printf("v = %d
", mi);
}

int main()
{
    /*
     * 1 const可以修饰类的对象 
     * 2 const修饰的对象为只读对象
     * 3 只读对象的成员变量不可以修改
     * 4 只读对象是编译阶段的概念，运行时无效
    */
    /*
     * 1 只读对象只能调用const成员函数
     * 2 const成员函数 只能 调用const成员函数
     * 3 const成员函数 不能 直接修改成员变量的值
    */
    const Test t(1);    
    printf("v = %d
", t.getMi()); // 只读对象只能调用const成员函数

    
    return 0;
}