C++:18---const关键字（附常量指针、指针常量、常量指针常量）

一、const变量的一些基本特点

• ①const修饰的变量不能被修改

1. const int a=10;
2. a=20;//错误

• ②因为const修饰的变量不能被修改，所以必须被初始化

3. int a=10;
4. const int b=a; //正确
5. const int c=10; //正确

• ③const修饰的变量可以赋值给其他值

6. const int a=10;
7. int b=a;//正确

• ④可以有常量引用

8. int a=10;
9. const int &b=a;

二、在其他文件中使用const常量（extern）

• const常量默认只能在当前文件使用，可以使用extern使const常量在文件中共享
• 注意：在别的文件中使用const常量时，如果出现同名时：①其他文件的局部变量会覆盖const常量。②其他文件的全局变量会报错，显示重定义

方法：

• 在demo.h文件中extern const int a;//声明
• 在demo.c文件中extern const int a=1;（extern可省略）

三、const和引用

• 把引用绑定到const对象上，就像绑定到其他对象上一样，我们称之为“对常量的引用”
• 与普通的引用不同的是，对常量的引用不能被用作修饰它所绑定的对象：

1. const int ci = 1024;
2. 
   
3. const int &r1 = ci; //正确，引用到常量上
4. r1 = 42; //错误，不能对常量的引用进行修改
5. int &r2 = ci; //错误，不能让一个非常量引用指向一个常量对象
6. //因为引用可以通过改变自身值而改变所引用的值，所以为了防止引用改变值，禁止使用普通引用引向const常量

初始化和对const的引用

•  在引用的文章中介绍，引用的类型必须与其引用的对象类型一致，但是有两个例外：

• ①在初始化常量引用时允许用任意表达式作为初始值，只要该表达式的结果能转成引用的类型即可（见下面代码段1）
• ②允许为一个常量引用绑定非常量的对象、字面值、甚至是个一般表达式（见下面代码段2）

1. //代码段1
2. double dval = 3.14;
3. const int &ri = dval;//正确
4. 
   
5. /*
6. 上面的代码会生成一个int类型的临时变量，然后将临时变量赋值给ri，因此上述代码可以扩展为：
7. double dval = 3.14;
8. const int temp = dval; //临时变量
9. const int &ri = temp ;
10. */

1. //代码段2
2. int i = 42;
3. const int &r1 = i; //正确，允许将const int&绑定到一个普通对象上
4. const int &r2 = 42; //正确
5. const int &r3 = r1 * 2;//正确
6. int &r4 = r1 * 2; //错误

四、常量和指针

• 也可以用const来修饰指针，指向常量的指针不能用于改变其所指对象的值
• 常量只能由常量指针来指向，不能由非常量指针来指向

1. const double pi = 3.14;
2. 
   
3. double *ptr = π //错误。ptr是非常量的
4. const double *cptr = π//正确

• 可以使用常量指针指向一个非常量对象：

5. double dval = 3.14;
6. const double *cptr = &dval; //正确

• 不能通过常量指针改变所指对象的值：

7. const double dval = 3.14;
8. const double *cptr = &dval; //正确
9. *cptr = 6.28; //错误
10. 
    
11. double dval2 = 3.14;
12. const double *cptr2 = &dval; //正确
13. *cptr2 = 6.28; //错误

五、常量指针、指针常量、常量指针常量

• 常量指针：（指向常量的指针）。指向可以改，但是不能通过该指针改变所指向的值

• 这种类型的const也被称为“底层const”：表示指针所指向的值是个常量

• 指针常量：（指针的常量）。指向不可以改，但可以通过该指针改变所指向的值
• 这种类型的const也被称为“顶层const”：表示指针本身是个常量
• 常量指针常量：不可以修改指向，也不可以修改所指向的值

1. const int* pa; //常量指针
2. int const* pb; //常量指针
3. 
   
4. int * const pc; //指针常量
5. 
   
6. int const* const pd;//常量指针常量

如果通过const的位置来判断const对什么起作用：

• const对左边的类型起作用，当const左边没有东西时，才对右边的起作用，因此有以下规则：

• 常量指针时，const左边为int或const左边无内容右边有int，因此只对int（值）生效，所以为常量指针
• 指针常量时，const左边为*（代表指针），所以为指针常量
• 常量指针常量时，有两个const，对int（值），*（指针）都生效，因此为常量指针常量

• 当然，上面的规则可以简化为下面一句话：
• const出现在“*”号的左边，代表所指之物是常量
• const出现在“*”号的右边，代表指针自身是个常量

初始化与使用

• 常量指针，因为所指对象是个常量，所以有下面的规则

• 可以常量指针指向于常量或非常量
• 但是不能修改值

1. int a = 1;
2. const int b = 2;
3. 
   
4. const int *pa = &a; //正确，可以指向非常量
5. pa = &b; //正确，指向可以改变
6. 
   
7. *pa = 1; //不能通过常量指针修改所指对象的值

• 指针常量，因为指针是个常量，而不是类型是常量，因此有下面的规则：

• 只能指向于非常量，不能指向于常量（因为放置指针常量修改常量的值）
• 不可以改变指针常量的指向，因为指针自身是个常量

1. int a = 1;
2. const int b = 2;
3. int c = 3;
4. 
   
5. int* const pa = &a; //正确，a是非常量
6. int* const pb = &b; //错误，b是常量
7. 
   
8. *pa = 10; //正确，可以修改指向对象的值
9. pa = &c; //错误，不能修改pa的指向（因为指针自身是个常量）

• 常量指针常量，有如下规则：

• 可以使用常量、非常量赋初值
• 不能改变值、不能改变指向

1. int a = 1;
2. const int b = 2;
3. 
   
4. const int *const p1 = &a; //正确
5. const int *const p2 = &b; //正确
6. 
   
7. *p1 = 2; //错误
8. p1 = &b; //错误

之间的转换

• 转换的规则是：非常量可以转换为常量，反之不行

1. int i = 0;
2. int j = 0;
3. const int ci = 42;
4. 
   
5. const int *p2 = &ci;
6. int *const p1 = &j;
7. const int *const p3 = p2;
8. p3 = p1; //错误，p3的指向也不能更改
9. 
   
10. int *p = p3; //错误，p3包含const，而p没有
11. p2 = p3; //正确，p2和p3都包含底层const
12. p1 = p3; //错误，p1的指向不能更改