C++ 里面的指针常常使初学者感到困惑，尤其是和引用，常量，数组等组合起来的时候，一个变量是数组，还是指针，指针是常量，还是所指对象是常量就显得更模棱两可了，例如下面这些代码：
|
1 2 3 4 5 |
int &r2 = *p; int * * pp = &p; const int * p2 = &i; deltype( r+0 ) b; int (*p_array)[10]; |
如果你也有类似的困惑的话，希望在读完本文之后，会有一个清晰的概念。
热身
一个内存位置，保存一个值，内存位置也可以作为值，这就叫做指针。在事情变得复杂之前，我们可以确定两件事：一个变量保存的要么是地址，要么是值。现在，我们从最简单的概念开始：
- 指针保存的是地址，解引用得到对象的值；
- 引用类型是真实对象的“绑定”，可以当做这个对象的另一个名字来使用，对引用类型的操作，就是对真实对象的操作（引用必须初始化！）。取地址得到的是对象的地址；
- 解引用 * ，取地址 & 具有双重含义：在表达式中作用如1 2 粗体所示；在声明中，它们用来组成复合类型。注意：int *p = i；
举个栗子：
|
1 2 3 4 5 6 7 8 |
int i = 42; int &r = i; //这是引用，r 是 i 同义词，作为变量名使用 int *p; //这是指针定义 p = &i; //&i是取 i 的地址，返回一个地址，p 是指针，保存的是地址 *p = i; //i是变量，值42，*p 是指针解引用，指向了 i int &r2 = *p; //r2定义为引用，*p 是对 p 解引用，指向了 i，所以 r2编程了 i 的同义词 *p = 32; &r2 = 23; |
那么问题来了：改变的是指针指向的对象呢？还是对象的值呢？
法则一：改变的永远是等号左侧的对象。
比如，第2行，等号的左侧是定义，r 是 int 类型的引用，引用“绑定”了 i；第4行，等号左侧是指针，那么改变的就是 指针的值，也就是所指的对象；第7行，等号左边是指针解引用，那么修改的就是指针指向的对象，即 i；最后一行，等号左侧是引用类型取地址，是一个地址，额，对一个地址赋值，很显然这一行是错误的……
注意：虽然上文说了某些符号在定义式中有另一种含义，但这还是常常使人混淆——*p不应该是变量的值吗？ 我有个小技巧，将在定义式中的*理解成为类型的一部分，将它看成和 int 的组合就好了，像这样：int * p = i;
复合类型
上面的概念是不是很简单？接下来要将指针和引用相互组合，产生更复杂的类型了。
指向指针的指针
首先，指针先指向了一个对象。这个对象保存的是个地址，对这个地址解引用，可以得到令一个对象的值。
|
1 2 3 |
int i = 42; int * p = i; //指向 i 的指针 int * * pp = &p; //指向 指针p 的指针 |
在内存中，是这个样子的：
指向指针的引用
由于引用不是真实的对象，所以不存在“指向引用的指针”，但却可以有“指向指针的引用。”这时，上文的规则同样适用，即作为指针的别名使用。
|
1 2 3 4 5 |
int i = 42; int *p; int *&r = p; //r 是指针 p 的引用 r = &i; //指针 p 指向了 i *r = 0; //i 赋值为0 |
现在就有点复杂了，r 到底是指针还是引用呢？法则二：从右向左读。例如第三行的 r ，左边是 &，所以它是个引用类型，再向右，* 表示引用的这个类型是一个指针，再向右 int 表示，这个指针的类型是int，综合，r就表示“一个指向 int 型的指针的引用。
const限定符和constexpr
当 const 涉及指针的时候，可以分为两种情况：
- 顶层const：指针本身是个常量，不能改变所指的对象。
- 底层const：指针指向的对象是一个常量，不能改变或者通过指针改变这个对象的值。
|
1 2 3 4 |
int i = 42; int *const p1 = &i; //常量指针，顶层const const int * p2 = &i; //p2指向一个常量 i const int * const p3 = p2; //p3是一个常量指针，指向了一个int常量，第一个const是底层，第二个是顶层 |
不要慌，这里法则二依然适用：从右向左。对于 p1，右侧是 const ，表示 p1 是一个常量，向右，p1 是常量指针，再右，常量指针 p1 指向了 int 型。
小试牛刀：解释一下p2和p3吧！
constexpr
这是 C++11 的新规定，允许将变量声明为 constexpr 类型以便由编译器来验证变量的值是否是一个常量表达式。
|
1 2 3 4 5 |
constexpr int a = 20; //a是一个常量 int j; constexpr int b = a + 1; // constexpr int *p = &j; //p是一个常量指针 constexpr const int *q = &a; //q是一个常量指针，指向一个int常量 |
“变量的值”，就是左值，说白了就是基本类型是不是一个常量。比如 a 基本类型是 int ，constexpr 就指定 int 型为常量。 p 是一个指针，constexpr 指定指针 p 是一个常量。由此，我们可以得到法则三：constexpr 声明中如果有指针，那么constexpr 只对指针有效，而与对象无关。
类型别名
类型别名顾名思义，就是将复杂的变量名起一个好听好记的名字。可以参考1-3行，这是类型别名的常用的例子（其实最常用的时候，是给长长的结构体取“外号”）。
|
1 2 3 4 5 6 7 8 9 |
typedef int num; //在这里，num 就是 int 的别名 typedef num No,*pointer; //No 和 num ,int 是同义词，p是 int 型指针 using num = int; //C++11 风格，用途和第1行完全一样 typedef char *pstring; const pstring c_p_str = 0; // c_p_str 是指向 char 类型的常量指针 const char * p_c_str = 0; // p_c_str 是指向 char 常量的指针 const pstring *ps; |
看完了前3行之后，你可能觉得“就是个别名，那我理解的时候，替换成原来的名字就好了！”所以你就会像 p_c_str 那样，去解释 c_p_str ：按照我们的从“右向左法则”，它首先是一个指针，然后指向 char 型，这个 char 型是 const 的，所以这是一个“指向char 型常量的指针”。
这是完全错误的！是我们的“从右向左”法则出错了吗？不是的，要相信，从右向左在任何时候都是对的，如果它错了，那么一定是你错了——你错就错在，将 typedef 指定的别名拆开理解了。正确的理解很简单，对于 typedef，你要从心底认为这是同一个类型的别名，pstring 是“指向 char 型的指针”，永远都是。对于 c_p_str，从右向左的时候，第一步是“它是一个指向 char 型的指针”，而不是“它是一个指针”。第二步理所应当的是“这个指针的类型是 const 的”，综合，c_p_str 就是“指向 char 类型的常量指针”。
法则四：typedef 定义的类型别名不要替换成原来的名字去理解！
小试牛刀，解释一下 ps 吧！答案是：“ps 是一个指针，它指向了一个对象，这个对象是一个指向 char 的常量指针。”
decltype 类型指示符
这也是 C++11 的新标准，编译器分析表达式并返回其类型，要注意的是，不会计算表达式的值。这点非常重要，因为上文说过，引用从来都是作为所指对象的同义词出现，但只有在deltype 的时候是个例外。原因如下：
|
1 2 3 |
int i = 42, *p = &i,&r = i; deltype( r+0 ) b; // 加法的结果是int类型，所以deltype返回int类型 deltype(*p) c; // p解引用得到一个引用类型，返回，所以c的类型是引用类型 |
第三行因为编译器阶段并不会对 *p 求值，所以直接返回一个引用类型。这个地方，引用就和所绑定的对象有区别了。（事实上，第三行是错误的，因为定义引用的时候没有初始化。）
法则五：在（且仅在）deltype 处，引用不是对象的同义词！
数组
引用可以绑定数组，指针可以指向一个数组，数组可以存放指针，但是唯独不存在引用的数组！参考下面的例子：
|
1 2 3 4 5 |
int arr[10]; int *p[10]; //保存指针的数组 int &refs[10]; //都说了没有引用的数组了 = = int (*p_array)[10]; //p_array 指向了含有10个整数的数组 int (&refs)[10]; //refs绑定了一个含有10个整数的数组 |
很显然，这里不能再用从右向左了，不然的话，”[ ]”永远也读不到了。对于负责的数组声明，要由（内）向外阅读——法则六。
例如 p_array ，首先，它是一个指针（内指的是括号内），然后类型修饰符从右向左再依次绑定：指向的是一个数组，这个数组是int型。 再复杂的数组，也可以以此类推。
Summary
- 改变的永远是等号左侧的对象。
- 从右向左读（类型修饰符依次绑定）。
- constexpr 声明中如果有指针，那么constexpr 只对指针有效，而与对象无关。
- typedef 定义的类型别名不要替换成原来的名字去理解！
- 在（且仅在）deltype 处，引用不是对象的同义词！
- 对于复杂的数组声明，要先从内向外读，再按照从右向左。
是不是 So easy 呢？你会读了吗？
