c++中的 const 关键字

知识回顾：C语言中 const

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

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

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

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

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

 #include <stdio.h>

 int main()
 {
     const int c = ;   // c 是只读变量
     int* p = (int*)&c;

     *p = ;

     printf("c = %d\n", c);  // c = 5

     return ;
 }
 // 编译器 gcc

c语言中 const

---

---

c++ 中 const

1. const 常量

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

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

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

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

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

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

 #include <stdio.h>

 int main()
 {
     const int c = ;   // c 是常量
     int* p = (int*)&c;

     *p = ;

     printf("c = %d\n", c);  // c = 10

     return ;
 }

 // 编译器 g++

const 常量

　　　　

　　3）const 常量 与 宏定义

　　　　相同点：

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

　　　　不同点：

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

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

 #include <stdio.h>

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

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

 int main()
 {
     const int A = ;
     const int B = ;
     int array[A + B] = {};
     int i = ;

     for(i=; i<(A + B); i++)
     {
         printf("array[%d] = %d\n", i, array[i]);
     }

     f();
     g();

     return ;
 }

const常量 与 宏定义

---

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

　　　　1）const 常量的判断方法：

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

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

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

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

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

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

 #include <stdio.h>

 int main()
 {
     const int x = ;    // 只有用  字面量  初始化的const常量才进入符号表--- 此处x进入符号表，x是常量
     const int& rx = x;  // 编译器分配给常量x的内存地址的别名为 rx--- rx是只读变量

     int& nrx = const_cast<int&>(rx);    // 去除只读变量rx的只读属性 --- nrx

     nrx = ;

     printf("x = %d\n", x);          //
     printf("rx = %d\n", rx);        //
     printf("nrx = %d\n", nrx);      //
     printf("&x = %p\n", &x);        // 0x7ffd8aed8f90
     printf("&rx = %p\n", &rx);      // 0x7ffd8aed8f90
     printf("&nrx = %p\n", &nrx);    // 0x7ffd8aed8f90    

     volatile const int y = ;       // volatile 修饰的const常量不会进入符号表---y是只读变量
     int* p = const_cast<int*>(&y);  // 去除y的只读属性

     *p = ;

     printf("y = %d\n", y);  //
     printf("&y = %p\n", &y);// 0x7ffd8aed8f94
     printf("p = %p\n", p);  // 0x7ffd8aed8f94

     const int z = y;    // 用 其它变量 初始化const常量，仍是只读变量 --- z是只读变量

     p = const_cast<int*>(&z);   // 去除z的只读属性

     *p = ;

     printf("z = %d\n", z);  //
     printf("&z = %p\n", &z);// 0x7ffd8aed8f98
     printf("p = %p\n", p);  // 0x7ffd8aed8f98

     char c = 'c';
     char& rc = c;
     const int& trc = c; //const引用类型 与 初始化变量的类型不一致，则生成新的只读变量 --- trc为新的只读变量

     printf("c = %c\n", c);      // c
     printf("rc = %c\n", rc);    // c
     printf("trc = %c\n", trc);  // c

     rc = 'a';

     printf("c = %c\n", c);      // a
     printf("rc = %c\n", rc);    // a
     printf("trc = %c\n", trc);  // c

     return ;
 }

1）2）结论的代码展示

　　　　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\n", mi);
 }

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

     return ;
 }

const 对象 和 const 成员函数