分清 C++的指针、引用和数组

C++ 里面的指针常常使初学者感到困惑，尤其是和引用，常量，数组等组合起来的时候，一个变量是数组，还是指针，指针是常量，还是所指对象是常量就显得更模棱两可了，例如下面这些代码：

int &r2 = *p;
int * * pp = &p;
const int * p2 = &i;
deltype( r+0 ) b;
int  (*p_array)[10];

int &r2 = *p;

int * * pp = &p;

const int * p2 = &i;

deltype( r+0 ) b;

int (*p_array)[10];

如果你也有类似的困惑的话，希望在读完本文之后，会有一个清晰的概念。

热身

一个内存位置，保存一个值，内存位置也可以作为值，这就叫做指针。在事情变得复杂之前，我们可以确定两件事：一个变量保存的要么是地址，要么是值。现在，我们从最简单的概念开始：

指针保存的是地址，解引用得到对象的值；
引用类型是真实对象的“绑定”，可以当做这个对象的另一个名字来使用，对引用类型的操作，就是对真实对象的操作（引用必须初始化！）。取地址得到的是对象的地址；
解引用 * ，取地址 & 具有双重含义：在表达式中作用如1 2 粗体所示；在声明中，它们用来组成复合类型。注意：int *p = i；

举个栗子：

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;

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;

复合类型

上面的概念是不是很简单？接下来要将指针和引用相互组合，产生更复杂的类型了。

指向指针的指针

首先，指针先指向了一个对象。这个对象保存的是个地址，对这个地址解引用，可以得到令一个对象的值。

int i = 42;
int * p = i; //指向 i 的指针
int * * pp = &p; //指向 指针p 的指针

int i = 42;

int * p = i; //指向 i 的指针

int * * pp = &p; //指向指针p 的指针

在内存中，是这个样子的：

指向指针的引用

由于引用不是真实的对象，所以不存在“指向引用的指针”，但却可以有“指向指针的引用。”这时，上文的规则同样适用，即作为指针的别名使用。

int i = 42;
int *p;
int *&r = p; //r 是指针 p 的引用
r = &i; //指针 p 指向了 i
*r = 0; //i 赋值为0

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：指针指向的对象是一个常量，不能改变或者通过指针改变这个对象的值。

int i = 42;
int *const p1 = &i; //常量指针，顶层const
const int * p2 = &i; //p2指向一个常量 i
const int * const p3 = p2; //p3是一个常量指针，指向了一个int常量，第一个const是底层，第二个是顶层

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 类型以便由编译器来验证变量的值是否是一个常量表达式。

constexpr int a = 20; //a是一个常量
int j;
constexpr int b = a + 1; //
constexpr int *p = &j; //p是一个常量指针
constexpr const int *q = &a; //q是一个常量指针，指向一个int常量

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行，这是类型别名的常用的例子（其实最常用的时候，是给长长的结构体取“外号”）。

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;

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 的时候是个例外。原因如下：

int i = 42, *p = &i,&r = i;
deltype( r+0 ) b; // 加法的结果是int类型，所以deltype返回int类型
deltype(*p) c; // p解引用得到一个引用类型，返回，所以c的类型是引用类型

int i = 42, *p = &i,&r = i;

deltype( r+0 ) b; // 加法的结果是int类型，所以deltype返回int类型

deltype(*p) c; // p解引用得到一个引用类型，返回，所以c的类型是引用类型

第三行因为编译器阶段并不会对 *p 求值，所以直接返回一个引用类型。这个地方，引用就和所绑定的对象有区别了。（事实上，第三行是错误的，因为定义引用的时候没有初始化。）

法则五：在（且仅在）deltype 处，引用不是对象的同义词！

数组

引用可以绑定数组，指针可以指向一个数组，数组可以存放指针，但是唯独不存在引用的数组！参考下面的例子：

int arr[10];
int *p[10]; //保存指针的数组
int &refs[10]; //都说了没有引用的数组了 = = 
int  (*p_array)[10]; //p_array 指向了含有10个整数的数组
int (&refs)[10]; //refs绑定了一个含有10个整数的数组

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 呢？你会读了吗？