声明：本文是学习《C++ Primer》（王刚 杨巨峰译）过程中记录下的摘抄笔记。感谢两位译者翻译之功！

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

引用

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

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

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

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

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

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

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

    int ii = refVal; //与ii = ival执行结果相同
    //正确：refVal3绑定到了与那个refVal绑定的对象上，此处即是ival上。
    int &refVal3 = refVal;
    // 利用与refVal绑定的对象的值初始化变量id
    int i = refVal;// 正确：i被初始化为ival的值

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

引用的定义

• 引用标识符必须以符号&开头
• 引用的类型要和与之绑定的对象严格匹配（两种情况除外：1.初始化常量引用时允许用任意表达式作为初始值，只要改表达式的结果能转换成引用的类型即可；2.存在继承关系的类）
• 引用只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起

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

指针

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

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

定义指针类型的方法就是将声明符写成*d的形式，其中d是变量名。

获取对象的地址

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

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

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

指针的类型都要和它所指向的对象严格匹配（两种情况除外：1.初始化常量引用时允许用任意表达式作为初始值，只要改表达式的结果能转换成引用的类型即可；2.存在继承关系的类）：

    double dval ;
    double *pd = &dval;//正确：初始值是double型对象的地址
    double *pd2 = pd;// 正确：初始值是指向double对象的指针
    
    int *pi = pd;// 错误：指针pi的类型和pd的类型不匹配
    pi = &dval;// 错误：试图把double型对象的地址赋给int型指针

因为在声明语句中指针的类型实际上被用于指定它所指向对象的类型，所以二者必须匹配。如果指针指向了一个其他类型的对象，对该对象的操作将发生错误。

指针值

指针的值（即地址）应属下列四种状态之一：

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

试图拷贝或以其他方式访问无效指针的值都将引发错误，这一点和使用未经初始化的局部变量是一样的。访问无效指针的后果无法预测，因此程序员必须清楚任意给定的指针是否有效。

利用指针访问对象

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

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

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

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

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

空指针

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

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

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

    int zero = 0;
    int *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不指向任何对象了

要想判断一条赋值语句到底是改变了指针的值还是改变了指针所指对象的值，最好的办法就是记住赋值拥有改变的是等号左侧的对象。

其他指针操作

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

    int ival = 1024;
    int *pi = 0;       //pi合法，是一个空指针
    int *pi2 = &ival;  //pi2是一个合法指针，存放着ival的地址
    if (pi)            //pi的值是0，因此条件的值是false
    {
        //
    }
    if (pi2)           //pi2指向ival，因此它的值不是0，条件的值是true。
    {
        //
    }

void*指针

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

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

利用void* 指针能做的事情比较有限：和其他指针比较、作为函数的输入输出、或者赋给另外一个void* 指针。不能之间操作void*指针所指的对象，因为我们并不清楚这个对象到底是什么类型，也就无法确定能在这个对象上做哪些操作。

理解复合类型的声明

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

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

变量的定义包括基本数据类型和声明符，类型修饰符（*、&）是声明符的一部分

定义多个变量

涉及指针或引用的声明，一般又两种写法：

1. 修饰符和变量标识符写在一起

    int *p1, *p2; //P1和p2都是int型指针

2. 修饰符和类型名写在一起，并且每条语句只定义一个变量

    int* p1;      //p1是int型指针
    int* p2;      //p2是int型指针

这两种写法并无优劣之分，主要是要坚持一种写法，保证代码可读性，避免混合使用

指向指针的指针

一般来说，声明符中类型修饰符的个数并无限制。若有多个修饰符连写，按照逻辑关系详加解释即可。以指针为例，指针是内存中的对象，也有自己的地址，因此允许把指针的地址再存放到另一个指针当中。

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

    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;          // 解引用得到i，也就是p指向的对象，将i的值改为0

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