C++复合类型（compound type）——引用和指针

复合类型（compound type）是指基于其他类型定义的类型。C++语言中有几种复合类型，最常用的引用和指针。

一个简单的声明语句由一个数据类型和紧随其后的一个变量名列表组成。其实更通用的描述是，一条声明语句由一个基本数据类型（base type）和紧随其后的一个声明符（declarator）列表组成。每个声明符命名了一个变量并指定该变量为与基本数据类型有关的某种类型。

我们更常见到的声明语句中，声明符其实就是变量名，此时变量的类型也就是声明的基本数据类型。其实还可能有更复杂的声明符，它基于基本数据类型得到更复杂的类型，并把它指定给变量。

1.引用

C++新增了一中引用：“右值引用”。该种引用主要用于内置类。我们使用术语“引用（reference）”时，指的是“左值引用（lvalue reference）”。

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

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

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

【引用即别名】

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

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

refVal = 2;        //把2赋给refVal指向的对象，此处即是赋给ival
int ii = refVal;    //与ii = ival执行的结果别无二致

 为引用赋值，实际上是把值赋给了与引用绑定的对象。获取引用的值，实际上时获取了与引用绑定的对象的值。同理，以引用作为初始值，实际上是以与引用绑定的对象作为初始值：

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

因为引用本身不是一个对象，所以不能定义引用的引用。

【引用的定义】

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

int i = 124， i2 = 2048;    //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 = dval;     //错误:此处引用类型的初始值必须是int对象，而可以是double对象

2.指针

指针（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的地址，或者说是指向变量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种状态之一：

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

试图拷贝或者以其他方式访问无效指针的值都将引发错误。编译器并不负责检查此类错误，这一点和试图使用未经初始化的变量是一样的。访问无效指针的后果无法预计，因此程序员必须清楚任意给定的指针是否有效。尽管第2种和第3种形式的指针是有效的，但其使用同样受到限制。显然这些指针没有指向任何具体对象，所以试图访问此类指针（假定的）对象的行为不被允许。如果这样做了，后果也无法预计。

【利用指针访问对象】

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

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

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

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

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

某些符号的多重含义：

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

int i = 42;                
int &r = i;           // &紧随类型名出现，因此是声明的一部分，r是一个引用
int *p;               // *紧随类型名出现，因此是声明的一部分，p是一个指针
p = &i;               // &出现在表达式中，是一个取地址符
*p = i;               // *出现在表达式中，是一个解引用符
int &r2 = *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新标准刚引入的一种方法。 nullptr是一种特殊类型的字面值，它可以被转成任意其他的指针类型。另一种方法就如对p2的定义一样，也可以通过将指针初始化为字面值0来生成空指针。

过去的程序还会用到一个名为NULL的预处理变量（preprocessor variable）来给指针赋值，这个变量在头文件cstdlib中定义，它的值就是0。在新的标准下，现在的C++程序最好使用nullptr，同时尽量避免使用NULL。

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

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

【赋值和指针】

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

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

int i = 42;
int *pi = 0;    // pi被初始化，但没有指向任何对象
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指向的那个对象）发生改变。 

【其他指针操作】

只要指针拥有一个合法值，就能将它用在条件表达式中。和采用算数值作为条件遵循的规则类似，如果指针的值是0，条件取false：

int ival = 1024;
int *pi = 0;            // pi合法，是一个空指针
int *pi2 = &ival;        // pi2是一个合法的指针，存放着ival的地址
if(pi)                    // pi的值是0，因此条件的值为false，pi为nullptr结果也一样
    //...
if(pi2)                   // pi2指向ival，因此他的值不是0，条件的值为true
    //...

任何非0的指针对应的条件值都是true。 

对于两个类型相同的合法指针，可以用相等操作符（==）或不相等操作符（!=）来比较它们，比较的结果是布尔类型。如果两个指针存放的地址相同，则它们相等；反之它们不相等。这里两个指针存放的地址值相同（两个指针相等）有三种可能：它们都为空、都指向同一个对象，或者都指向了同一个对象的下一个地址。需要注意的是，一个指针指向某对象，同时另一个指针指向另外对象的下一个地址，此时有可能出现这两个指针值相同的情况，即指针相等。

因为上述操作要用到指针的值，所以不论是作为条件出现还是参与比较运算，都必须使用合法指针，使用非法指针作为条件或进行比较都会引发不可预计的后果。

【void* 指针】

void*是一种特殊的指针类型，可以用于存放任意对象的地址。一个void*指针存放着一个地址，这一点和其他指针类似。不同的是，我们对该地址中到底是什么类型的对象并不了解：

double obj = 3.14, *pd = &obj;
//正确：void*能存放任意类型对象的地址
void *pv = &obj;    // obj可以是任意类型的对象
pv = pd             // pv可以存放任意类型的指针

利用void*指针能做的事儿比较有限：拿它和别的指针比较、作为函数的输入或输出，或者赋值给另外一个void*指针。不能直接操作void*指针所指的对象，因为我们并不知道这个对象是什么类型，也就无法确定能在这个对象上做哪些操作。

 概括来说，以void*的视角来看内存空间也就仅仅是内存空间，没办法访问内存空间中所存的对象。

3.理解复合类型

如前所述，变量的定义包括一个基本数据类型（base type）和一组声明符。在同一条定义语句中，虽然基本数据类型只有一个，但是声明符的形式却可以不同。也就是说，一条定义语句中可能定义出不同类型的变量：

// i是一个int型的整数，p是一个int型指针，r是一个int型引用
int i = 1024, *p = &i, &r = i;

请不要迷惑于基本数据类型和类型修饰符的关系，其实后者只不过是声明符的一部分罢了。

【定义多个变量】 

经常有一种观点会误以为，在定义语句中，类修饰符（*或&）作用于本次定义的全部变量。造成这种错误看法的原因有很多种，其中之一就是我们可以把空格写在类修饰符和变量名中间：

int* p;    //合法但极易产生误导

我们说这种写法可能产生误导是因为int*放在一起好像是这条语句中所有变量共同的类型一样。其实恰巧相反，基本数据类型是int而非int*。*仅仅是修饰了p而已，对该声明语句中的其他变量，它并不产生任何作用;

int* p1, p2;    // p1是指向int的指针，p2是int

涉及指针或引用声明，一般有两种写法。第一种把修饰符和变量标识符写在一起：

int *p1, *p2;    // p1和p2都是指向int的指针

这种形式着重强调变量具有的符合类型。第二种罢休师傅和类型名写在一起，并且每条语句只定义一个变量：

int* p1;    // p1和p2都是指向int的指针
int* p2;

【指向指针的指针】

一般来说，声明符中修饰符的个数没有限制。但有多个修饰符连写在一起时，按照其逻辑关系详加解释即可。以指针为例，指针是内存中的对象，像其他对象一样也有自己的地址，因此允许把指针的地址再放到另一个指针中。

通过*的个数可以区分指针的级别。也就是说，**表示指向指针的指针，***表示指向指针的指针的指针，以此类推：

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

下图描述ppi、pi与ival之间的关系：

【指向指针的引用】

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

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引用的是一个int指针。