C++指针和引用

复合类型（compound type）是指基于其他类型定义的类型。C++语言有几种复合类型，诸如结构体、共用体、枚举等，本文将介绍其中的两种：引用和指针。

C++11中新增了一种引用：所谓“右值引用（rvalue reference）”，这种引用主要用于内置类。严格来说，当我们使用术语“引用（reference）”时，指的是“左值引用（Ivalue reference）”。

引用为对象起了另外一个名字，引用类型引用（refer to）另外一种类型。通过将声明符写成&d的形式来定义引用类型，其中d是声明的变量名。

int ival = 1024;
int &refVal = ival; //re指向iv(是iv的另一个名字)
int &refVal2; //报错：引用必须被初始化

一般在初始化变量时，初始值会被拷贝到新建的对象中。然而定义引用时，程序把引用和它的初始值绑定（bind）在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因为无法令引用重新绑定到另外一个对象，因此引用必须初始化。

引用并非对象，相反的，它只是为一个已经存在的对象所起的另外一个名字。

定义了一个引用之后，对其进行的所有操作都是在与之绑定的对象上进行的：

refVal = 2; //把2赋给refVal指向的对象，此处即是赋给了ival
int ii = refVal; //与ii = ival执行结果一样

• 为引用赋值，实际上是把值赋给了与引用绑定的对象。
• 获取引用的值，实际上是获取与引用绑定的对象的值。
• 以引用作为初始值，实际上是以与引用绑定的对象作为初始值。
• 因为引用本身不是一个对象，所以不能定义引用的引用。

int &refVal3 = refVal;
//refVal3绑定到了那个与refVal绑定的对象上，这里就是绑定到ival上。
int i = refVal;
//利用与refVal绑定的对象的值初始化变量i,i被初始化为ival的值。

• 允许在一条语句中定义多个引用，其中每个引用标识符都必须以符号&开头：

int i = 1024, i2 = 2014; //i和i2都是int
int &r = i, r2 = i2;     //r是一个引用，与i绑定在一起，r2是int
int i3 = 1024, &ri = i3; //i3是int,ri是一个引用，与i3绑定在一起
int &r3 = i3, &r4 = i2;  //r3和r4都是引用

• 引用只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起。

int &refVal4 = 10;
//错误：引用类型的初始值必须是一个对象
double dval = 3.14;
int &refVal5 = davl;
//错误：此处引用类型的初始值必须是int型对象

指针（pointer）是“指向（point to）”另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的间接访问。然而指针与引用相比又有很多不同之处。

• 指针本身是一个对象，允许对其进行赋值和拷贝；
• 在指针的生命周期内，可以先后指向几个不同的对象；
• 指针无须在定义时赋初值；
• 和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值。

定义指针类型的方法将声明符写成*d的形式，其中d是变量名。如果在一条语句中定义了几个指针变量，每个变量前面都必须有符号*:

int *ip1, *ip2;
//ip1和ip2都是指向int型对象的指针
double dp, *dp2;
//dp2是指向double型对象的指针，dp是指向double型对象

指针存放某个对象的地址，要想获取该地址，需要使用取地址符（&）

int ival = 42;
int *p = &ival;
//p存放变量ival的地址，或者说p是指向变量ival的指针

第二条语句把p定义为一个指向int的指针，随后初始化p令其指向名为ival的int对象。

因为引用不是对象，没有实际地址，所以不能定义指向引用的指针。

指针的类型和它要指向的对象严格匹配：

double dval;
double *pd = &dval;
//正确：初始值是double型对象的地址
double *pd2 = pd;
//正确：初始值是指向double对象的指针

int *pi = pd;
//错误：指针pi的类型和pd的类型不匹配
pi = &dval;
//错误：试图把double型对象的地址赋给int型指针

指针的值，即地址应属于下列4种状态之一：

• 指向一个对象
• 指向紧邻对象所占空间的下一个位置
• 空指针，意味着指针没有指向任何对象
• 无效指针，也就是上述情况之外的其他值

试图拷贝或以其他方式访问无效指针的值都将引发错误。编译器并不负责检查此类错误这一点和试图使用未经初始化的变量是一样的。访问无效指针的后果无法预计,因此程序员必须清楚任意给定的指针是否有效。

尽管第2种和第3种形式的指针是有效的,但其使用同样受到限制。显然这些指针没有指向任何具体对象,所以试图访问此类指针(假定的)对象的行为不被允许。如果这样做了,后果也无法预计。

如果指针指向了一个对象，则允许使用解引用符（操作符*）来访问该对象：

int ival = 42;
int *p = &ival;
//p存放着变量ival的地址，或者说p是指向变量ival的指针
cout << *p;
//由符号*得到指针p所指的对象，输出42

对指针解引用会得出所指的对象，因此如果给解引用的结果赋值，实际上也就是给指针所指向的对象赋值：

*p = 0;
//由符号*得到指针p所指的对象，即可经由p为变量ival赋值
cout << *p;
//输出 0
//为*p 赋值实际上是为p所指的对象赋值。

解引用操作仅适用于那些确实指向了某个对象的有效指针。

空指针( null pointer)不指向任何对象，在试图使用一个指针之前代码可以首先检查它是否为空。以下列出几个生成空指针的方法：

int *p1 = nullptr;
//等价于 int *p1 = 0;
int *p2 = 0;
//直接将p2初始化为字面常量0
//需要首先#include cstdlib
int *p3 = NULL;
//int *p3 = 0;

得到空指针最直接的办法就是用字面值nullptr来初始化指针，这也是C++11新标准刚刚引入的一种方法。

当用到一个预处理变量时，预处理器会自动地将它替换为实际值，因此用NULL初始化指针和用0初始化指针是一样的。在新标准下，现在的C++程序最好使用nullptr，同时尽量避免使用NULL。

把int变量直接赋给指针是错误的操作，即使int变量的值恰好等于0也不行。

int zero = 0;
pi = zero;
//错误：不能把int变量直接赋给指针

使用未经初始化的指针是引发运行时错误的一大原因，因此建议：初始化所有的指针。

指针和引用都能提供对其他对象的间接访问，然而在具体实现细节上二者有很大不同，其中最重要的一点就是引用本身并非一个对象。一旦定义了引用，就无法令其再绑定到另外的对象，之后每次使用这个引用都是访问它最初绑定的那个对象。

指针和它存放的地址之间就没有这种限制了。和其他任何变量(只要不是引用)一样，给指针赋值就是令它存放一个新的地址，从而指向一个新的对象：

int i = 42;
int *p = 0;
//p被初始化，但没有指向任何对象
int *pi2 = &i;
//pi2被初始化，存有i的地址
int *pi3;
//如果pi3定义于块内，则pi3的值无法确定的

pi3 = pi2;
//pi3和pi2指向同一块对象i
pi2 = 0;
//现在pi2不指向任何对象了

有时候要想搞清楚一条赋值语句到底是改变了指针的值还是改变了指针所指对象的值不太容易，最好的办法就是记住赋值永远改变的是等号左侧的对象。当写出如下语句时，

pi = &ival;
//pi的值被改变，现在pi指向了ival

意思是为pi赋一个新的值，也就是改变了那个存放在pi内的地址值。相反的，如果写出如下语句

*pi = 0;
//ival的值被改变，指针pi并没有改变

则*pi也就是指针pi指向的那个对象发生改变。

像&和*这样的符号，既能用作表达式里的运算符，也能作为声明的一部分出现，符号的上下文决定了符号的意义：

int i = 42;
int &r = i;
//& 紧随类型名出现，因此是声明的一部分，r是一个引用
int *p;
//* 紧随类型名出现，因此是声明的一部分，p是一个指针
p = &i; 
//& 出现在表达式中，是一个取地址符
*p = i;
//* 出现在表达式中，是一个解引用符
int &r2 = *p;
//& 是声明的一部分，* 是一个解引用符

在声明语句中，&和*用于组成复合类型；在表达式中，它们的角色又转变成运算符。在不同场景下出现的虽然是同一个符号，但是由于含义截然不同，所以我们完全可以把它当作不同的符号来看待。

int ival = 1024;
int *pi = &ival;
//pi 指向一个int型的数
int **PPi = π
//ppi指向一个int型的指针

引用本身不是一个对象，因此不能定义指向引用的指针。但指针是对象，所以存在对指针的引用:

int i = 42;
int *p;
//p是一个int型指针
int *&r = p;
//r是一个对指针p的引用。
//引用在定义时，必须进行初始化，之后不可以进行更改了。

r = &i;
//r引用了一个指针,因此给r赋值&i就是令p指向i
*r = 0;
解引用r得到i,也就是p指向的对象,将i的值改为0

理解r的类型到底是什么，最简单的办法是从右向左阅读r的定义。离变量名最近的符号(此例中是&r的符号。)对变量的类型有最直接的影响，因此r是一个引用。声明符的其余部分用以确定r引用的类型是什么，此例中的符号*说明r引用的是一个指针。最后声明的基本数据类型部分指出r引用的是一个int指针。

面对一条比较复杂的指针或引用的声明语句时，从右向左阅读有助于弄清楚它的真实合义

推荐阅读：

参考书籍:

[1]C++ primer

[2]C 专家编程

[3]C陷阱与缺陷

[4]C和指针

感谢阅读：）

inner peace

知行合一