C++复合类型：指针和引用

复合类型

复合类型是指基于其他类型定义的类型。C++有几种复合类型，引用和指针。

复合类型的声明语句由一个基本数据类型和紧随其后的一个声明符列表组成。每个声明符命名了一个变量并指定该变量为与基本数据类型有关的某种关系。

引用

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

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

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

定义一个引用之后，对其进行的操作都是在与之绑定的对象上进行的，给引用赋值，实际上是把值赋给了与绑定的对象的值。同理，以引用为初始值，实际上是以与引用绑定的对象作为初始值。

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

引用只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起。所有引用的类型都要和与之绑定的对象严格匹配。

#include <iostream>
using namespace std;

int main(){
   int ival=1024;
   int &refval=ival;  //refval指向ival(ival的另一个名字)
   //int &refval2; //报错,引用必须初始化
   cout<<refval<<endl;  //输出1024
   ival=10;
   cout<<refval<<endl;  //输出10
   refval=7;  //把7赋给refval指向的对象，即赋给了ival
   cout<<ival<<endl;  //7
   int &refVal2=refval; //refVal2绑定到了与refval绑定的对象上，即绑定到了ival上
   int i=refval;  //把i初始化为ival的值
   cout<<refVal2<<endl; //7
   bool a=refVal2==ival; //true
   cout<<a<<endl; 
   return 0;
}

引用的定义

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

int i=1024,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 &refVal=10; //错误，引用类型的初始值必须是一个对象
double dval=3.43; 
int &refVal1=dval; //错误，此处引用类型的初始值必须是int型对象

指针

指针是指向另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的简介访问。

指针和引用的不同：
1. 指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象
2. 指针无须在定义时赋初值

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

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

获取对象的地址

指针存放某个对象的地址，想要获取该地址，需要使用取地址符（操作符&）
因为引用不是对象，没有实际地址，所以不能定义指向引用的指针

一般情况下所有指针的类型都要和它所指向的对象严格匹配。

#include <iostream>
using namespace std;
int main(){
   int *ip1,*ip2; //ip1和ip2都是指向int型对象的指针
   double dp,*dp2; //dp是double型对象,dp2是指向double型对象的指针
   int ival=320;
   int *p=&ival; //p存放变量ival的地址，或者说p是指向变量ival的指针
   cout<<*p<<"  "<<p<<"  "<<p+1<<endl;
   double dval=10.32;
   double *pd=&dval; //正确：初始值是double型对象的地址
   double *pd2=pd;  //正确：初始值是指向double对象的指针
   int *pi=pd; //错误：指针pi的类型和pd的类型不匹配
   pi=&dval; //错误：试图把double型对象的地址赋给int型指针
   return 0;
}

指针值

指针的值（即地址）应属于4种状态之一：
- 指向一个对象
- 指向紧邻对象所占空间的下一个位置
- 空指针，意味着指针没有指向任何对象
- 无效指针，也就是上述情况之外的其他值。试图拷贝或者以其他方式访问无效指针都将引发错误，编译器不负责检查此类错误

利用指针访问对象

如果一个指针指向了一个对象，则允许使用解引用符（操作符*）来访问该对象。
对指针解引用会得出所指的对象，因此如果给解引用的结果赋值，实际上也就是给指针所指的对象赋值。解引用操作仅适用于确实指向了某个对象的有效指针。

#include <iostream>
using namespace std;
int main(){
   int ival=320;
   int *p=&ival; //p存放变量ival的地址，或者说p是指向变量ival的指针
   *p=20; //由符号*得到指针所指的对象，即可经由p为变量ival赋值
   cout<<*p<<" " <<ival<<endl; //由符号*得到指针所指的对象，输出20
   return 0;
}

某些符号有多重含义

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

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

在声明语句中，&和*用于组成复合类型，在表达式中，它们的角色又转变成运算符。

总结（个人理解，如有错欢迎指出）：当一个语句的*d或者&d前有基本数据类型的就是定义一个指针或者引用（因为指针和引用都是复合类型，即如int *或者int &，而这个d就是指针或者引用，而非*d或&d，），而*用于表达式中表示解引用符，*d（d表示定义的指针，*是解引用符，字面上解释就是解开指针d的地址）就是d这个指针所指向对象的值（或者访问指针d存放的地址所得到的值），因此赋值给*d就要求等号右边的值与其所指向对象的类型一致，因为实际上是给其指向的对象赋值。而对于指针d，因此指针本身就是对象，因此赋值给指针的如果是对象的话一定要带有&（取地址符），因为指针存放的就是地址，给指针d赋值的意思就是指针d存放等号右边的值为地址。而对于引用d（而非&d）的赋值，它就是对象的别名但不是对象，因此等号右边的值与其所绑定的对象的类型一致即可。

空指针

空指针不指向任何对象，在试图使用一个指针之前可以检查它是否为空。
生成空指针的方法：

int *p1= nullptr; //c++11新标准，等价于int *p1=0
int *p2=0; //直接将p2初始化为字面常量0
int *p3-NULL; //NULL为预处理变量，在头文件cstdlib中，等价于int *p3=0

nullptr是一种特殊的字面值，它可以被转换成任意其他指针类型。

预处理器是运行于编译过程之前的一段程序。预处理变量不属于命名空间std，它由预处理器负责管理，因此可以直接使用预处理变量而无需在前面加上std::。当用到一个预处理变量时，预处理器会自动将它替换为实际值。C++程序最好使用nullptr，同时尽量避免使用NULL

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

赋值和指针

指针和引用都能提供对其他对象的间接访问，其中最重要一点是引用本身不是一个对象，。一旦定义了引用，就无法令其再绑定到另外的对象，之后每次使用这个引用都是访问它最初绑定的那个对象。

#include <iostream>
using namespace std;
int main(){
   int i=43;
   int *pi=0; //pi被初始化，但没有指向任何对象
   int *pi2=&i; //pi2被初始化，存有i的地址
   int *pi3; //如果pi3定义在块内，则pi3的值是无法确定的
   pi3=pi2; //pi3和pi2指向同一个对象
   pi2=0; //现在pi2不指向任何对象
   return 0;
}

要搞清楚一条赋值语句到底是改变了指针的值还是改变了指针所指对象的值最好的办法就是记住赋值永远改变的是等号左侧的对象。

pi=&i; //pi的值被改变，现在pi指向i，也就是改变了存放在pi内的地址值
*pi=340; //i的值被改变，指针pi并没有改变，也就是指针pi指向的对象发生改变

其他指针操作

如果指针的值是0，条件取false，任何非0指针对应条件值都是true。如果两个指针存放的地址相同则使用相等操作符（==）返回的结果是true，反之是false。

两个指针存放的地址值相同（两个指针相等）有三种可能：
- 它们都为空
- 都指向同一个对象
- 都指向了同一个对象的下一地址

void *指针

void *是一种特殊的指针，可用于存放任意对象的地址。一个void *指针存放着一个地址，但对该地址中到底是什么类型的对象并不了解。不能直接操作void *指针所指向的对象，因为不知道这个对象到底是什么类型的，就无法确定能在这个对象上做哪些操作。

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

理解复合类型的声明

在定义复合类型时，类型修饰符（*和&）只是声明符的一部分。

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

指向指针的指针

指针是内存中的对象，像其他对象一样也有自己的地址，因此允许把指针的地址在存放到另一个地址当中。
通过*的个数可以区分指针的级别，。也就是说两个*表示指向指针的指针，三个*表示指向指针的指针的指针。

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

如果要从ppi访问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引用的是一个指针。最后声明的基本数据类型部分指出r引用的是一个int指针。

以上大部分内容来自《C++Primer》