1、const 和 指针 的关系
1.1 基本情况
const 指针的关系主要存存在三种：
1、常指针（const pointer）
int* const p;
2、指针类型的常量（const to pointer）
const int *p;
int const *p;
3、指向常量的常指针
const int * const p;
那么这三种不同的类型是如何使用的呢？首先我们来看下面的代码：
#include<iostream>
using namespace std;
//1、const 和 指针 的关系
int main()
{
int a = 10;
int b = 20;
int *p1 = &a;
//1、const pointer
int * const p2 = &a;
//2、const to pointer
//这两种方式等价
const int * p3 = &a;
//int const * p3 = &a;
//3、
const int * const p4 = &a;
return 0;
}
1、常指针的修改
int main()
{
cout << *p2 << endl; //10;
*p2 = b; //rigth
cout << *p2 << endl; //20
p2 = &b; //error
}
我们可以发现，在const 修饰指针本身的时候（int *const p2）。我们可以修改指针解引用后的值，但是不能修改指针本身所指向的地址。
2、指针类型的常量的修改
int main()
{
cout << *p3 << endl;
//*p3 = b; //error
cout << *p3 << endl;
p3 = &b; //right
cout << *p3 << endl;
}
当指针是一个指向常量的指针时（const int *p3）。我们可以改变指针所指向的对象，但是不能修改指针解引用后的值。
3、指向常量的常指针修改
*p4 = b; //error
p4 = &b; //error
当指针是指向常量的常指针的时候，我们既不能修改指针本身，又不能修改指针解引用后的值。
1.2 常指针或者指针类型的常量
1.2.1 常指针 const int *p = &a;
int main()
{
int a = 10;
int b = 20;
const int *p = &a;
//int *s0 = p; //error,可以通过s0修改p指向的内容的值。
const int *s1 = p; //right,类型匹配
//int * const s2 = p; //error,s2的指向的地址不能改变，但是可以解引用来改变p的值，错误。
const int *const s3 = p; //right
return 0;
}
1.2.2 指针类型的常量 int * const p = &a;
int main()
{
int a = 10;
int b = 20;
int * const p = &a;
int *s0 = p; //right
const int *s1 = p; //right
int * const s2 = p; //right
const int *const s3 = p; //right
system("Pause");
return 0;
}
int *const p = &a; 这条代码表示p是一个常指针，这个指针所指向的是地址不可改变的。这个常指针存放的是a的地址。其他的指针指向的也是a的地址，这些指针的赋值是正确的。因为常指针仅仅只是规定指针p不可以指向其他的地址，并没有规定其他指针不能改变这个指针解引用的值。况且其他指针的修改也仅仅只是修改这些指针本身（s0、s1、s2、s3）解引用的值（p的值）或者指向的地址，编译可以正常通过。
1.3 const_cast
首先来看一个概念：只读变量（常变量）。
const int n = 5;
int a[n];
//C99：error
//C++：right
//ANSI C规定数组的大小必须是一个常量，常量不等于“不可变的变量”，
//但是C++中没有规定。
//常量的定义：enum枚举类型和#define宏定义定义的。
//只读变量：const 来定义。
//原因：常量被编译器存放在内存中的只读区域，不可修改。
// 只读变量会在内存中申请一块空间来存放它的值，只不过是编译器限定的不可修改。
所以说，在C++中我们会将常变量看作为常量。
int main()
{
const int a = 10;
int b = 20;
int *p = &a; //error：这样改变解引用的值会修改原先a的值，但是a是 //const类型不可修改，报错。
*p = b;
//int *p = const_cast<int *>(&a);
}
这段代码编译器会报错，原因如下：
要解决可以使用 C++的标准转换运算符const_cast。
C++提供了四个转换运算符来移除变量的const限定符：
- const_cast (expression)
- static_cast <new_type> (expression)
- reinterpret_cast <new_type> (expression)
- dynamic_cast <new_type> (expression)
只需将代码改为 int *p = const_cast<int *>(&a); 即可移除变量a的const 限定符，实现初始化。
2、const 和引用 的关系
2.1 什么是引用
引用就是某个变量的别名，对引用的操作对与变量的直接操作完全相同。
格式为：类型 & 引用变量名 = 已定义过的变量名。
2.2 引用和指针的区别
| 引用 | 指针 |
|---|---|
| 必须初始化 | 可以不初始化 |
| 不可为空 | 可以为空 |
| 不能更换目标 | 可以更换目标 |
| 没有二级引用 | 存在二级指针 |
1、引用必须初始化，而指针可以不初始化
int &s; //error:引用没用初始化
int *p; //right:指针不强制初始化
2、引用不可以为空，指针可以为空
int &s = NULL; //error:引用不可以为空，右值必须是已经定义过的变量名
int *p = NULL; //right:可以定义空指针。
int fun_p(int *p)
{
if(p != NULL) //因为指针可以为空，所以在输出前需要判断。
{
cout << *p << endl;
}
return *p;
}
int fun_s(int &s)
{
cout << s << endl; //引用不为空，可以直接输出
return s;
}
3、引用不能改变目标，指针可以更换目标
int main()
{
int a = 20;
int b = 10;
int &s = a;
int *p = &a;
s = b; //引用只能指向初始化时的对象，如果改变，原先对象也跟着改变。
p = &b; //指针可以改变指向的对象，不改变原先对象。
cout << s << endl;
cout << a << endl;
system("pause");
return 0;
}
2.3 指针和引用性能差异
指针：
void fun_p(int *p)
{
*p = 10;
return;
}
int main()
{
int a = 20;
int *p = &a;
fun_p(p);
}
通过objdump -d 命令来查看指针的反汇编代码：
引用:
void fun_s(int &s)
{
s = 10;
return;
}
int main()
{
int a = 20;
int &s = a;
fun_s(s);
}
通过objdump -d 命令来查看指针的反汇编代码：
我们可以清除的看出指针和引用的反汇编代码时基本一致的。这说明C++编译器在编译程序的时候将指针和引用编译成了完全一样的机器码。所以C++中的引用只是C++对指针操作的一个“语法糖”，在底层实现时C++编译器实现这两种操作的方法完全相同。
2.4 指针的引用
2.4.1 int *p = &a;
int main()
{
int a = 10;
int b = 20;
int *p = &a;
int *s = p;
//1、
//int *&pref1 = p; //指针的引用,p的别名叫做pref1。
//2、
//int &*pref2 = p; //error，引用不具有地址。
//3、
const int *&pref3 = p; //p的另一个名字叫pref3。
//由于是对指针解引用后的值添加const ，
//所以p（pref3）无法修改解引用的值
//但是可以改变p（pref3）所指向内容的地址
//pref3 = b; //error;
p = &b; //right
//pref3 = &b;
//4、
int *const &pref4 = p; //首先p的别名是pref4，const 修饰的是指针本身。表示指针p（pref4）无法对指针的指向进行修改。
//但是可以修改指针p（pref4）解引用后的值。
//p = &b; //error
*p = b; //right
//5、
const int *const &pref5 = p; //首先pref5是指针p的别名，前面的const修饰的是解引用的值，后面const修饰的是指针本身。
//所以它们解引用后的值和指针本身的地址都不可修改
system("pause");
return 0;
}
2.4.2 const int *p = &a;
int main()
{
int a = 20;
int b = 10;
const int *p = &a; //const修饰的是解引用后的值，表示p解引用后的值不可修改，但是可以修改P指向的地址。
int* &pref1 = p; //error :pref1是P的别名，但是如果这样命名，我们就可以通过*pref1来修改a的值，与我们定义的const 相违背。
*pref1 = b;
const int* &pref2 = p; //right：pref2是p的别名，通过*pref2也不可以修改p的值，从而改变a的值。但是我们可以通过改变p指向的地址，来指向不同的地址。这和const int *p的理念一致，所以是正确的
int* const &pref3 = p; //error：pref3是P的别名，const修饰了pref3不可指向其他的地址，但是可以通过*pref3来修改*p产生的值。
const int* const &pref4 = p; //pref4是p4的别名，两个const 限定了它的解引用和修改指针指向的地址。并且遵循能力收缩的原则。
return 0;
}
未完… …