复合类型

 

　　复合类型（compound type）是指基于其余类型定义的类型，C++语言有几种复合类型，这里只介绍两种：引用和指针

一：引用

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

　　int ival = 1024

　　int &refval = ival；//refval指向ival（是ival的另一个名字）

　　int &refval2；  //报错，引用必须初始化

通常在初始化变量的时候，初始值会被拷贝到新建的对象中，然而定义引用时，程序把引用和它的初始值绑定在一块儿，而不是将初始值拷贝给引用，一旦初始化完成，引用将和它的初始值对象一直绑在一块儿，由于没法令引用从新绑定到另一个对象，所以引用必须初始化。

　　

引用即别名

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

　　定义了一个引用以后，对其进行的全部操做都是在与之绑定的对象上进行的；

　　refval = 2；  //把2赋值给refval指向的对象，此处便是赋值给了ival；

　　int ii = refval； //与ii = ival执行的结果是同样的。

为引用赋值，其实是把值赋给了与引用绑定的对象，获取引用的值，其实是获取了与引用绑定的对象的值，同理，以引用做为初始值，其实是以与引用绑定的对象做为初始值；

　　//正确：refval3绑定到了那个与refval绑定的对象上，这里就是绑定到ival上

　　int &refval3 = refval；

　　//利用与refval绑定的对象的值初始化变量

　　int i = refval；//正确，i 被初始化为ival的值

　　由于引用自己不是一个对象，因此不能定义引用的引用；

 

引用的定义

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

　　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 &refval4 = 10;   //错误，引用类型的初始值必须是一个对象。

　　double dval = 3.14；

　　int &refval5 = dval； //错误，此处引用类型的初始值必须是int型对象。

 

二：指针

　　指针（pointer）是指向（point to）另一种类型的复合类型，与引用相似，指针也实现了对其它对象的间接访问，然而指针与引用相比又有不少不一样点，其一，指针自己就是一个对象，容许对指针赋值和拷贝，并且在指针的生命周期内它能够前后指向几个不一样的对象。其二，指针无须在定义时赋值，和其它内置类型同样，在块做用域内定义的指针若是没有被初始化，也将拥有一个不肯定的值。

　　WARNING：指针一般难以理解，即便是有经验的程序员也经常由于调试指针引起的错误而备受折磨。

　　定义指针类型的方法将声明符写成*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种状态之一：

　　1：指向一个对象；

　　2：指向紧邻对象所占空间的下一个位置；

　　3：空指针，意味着指针没有指向任何对象；

　　4：无效指针，也就是上述状况以外的位置；

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

尽管第2种和第三种形式的指针是有效的，但其使用一样受到限制，显然这些指针没有指向任何具体的对象，因此试图访问此类指针对象的行为不被容许，若是这样作了，后果也是没法预计的。

 

利用指针访问对象

　　若是指针指向了一个对象，则容许使用解引用符（操做符*）来访问对象；

　　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 *p = nullptr； //等价于int *p = 0；

　　int *p2 = 0； //直接将p2初始化为字面常量0；

　　//须要首先#include<cstdlib>

　　int *p3 = NULL; // 等价于int *p3 = 0;

获得空指针最直接的办法就是用字面值nullptr来初始化指针，这也是C++11新标准刚刚引入的一种方法，nullptr是一种特殊类型的字面值，它能够被转换成任意其余指针类型，另外一种方法就是如对p2的定义同样，也能够经过将指针初始化为字面值0来生成空指针。

过去的程序还会用到一个名为NULL的预处理变量来给指针赋值，这个变量在头文件cstdlib中定义，它的值就是0

当用到一个预处理变量时，预处理器就会自动将它替换为实际值，所以用NULL来初始化指针和用0来初始化指针是同样的，在新标准下，如今的C++最好使用nullptr，同是应尽可能避免使用NULL。

　　把int变量直接赋值给指针是错误的操做，即便int变量的值刚好是0也不行

　　int zero = 0；

　　int *pi;

　　pi = zero； //错误，不能把int变量直接赋值给指针

建议

 　　使用未经初始化的指针是引起运行时错误的一大缘由。

　　和其它变量同样，访问未经初始化的指针所引起的后果是没法预计的，一般这一行为将形成程序崩溃，并且一旦崩溃，要想定位到出错的位置将是特别棘手的问题。

　　在大多数编译器环境下，若是使用了未经初始化的指针，则该指针多占内存空间的当前内容将被看作一个地址值。访问该指针，至关于访问一个本不存在的位置上的本不存在的对象，槽糕的是，若是指针所占内存空间中刚好有内容，而这些内容又被看成了某个地址，咱们就很难分清它究竟是合法仍是非法的了。

　　所以咱们建议初始化全部的指针，而且在可能的状况下，尽可能定义了对象以后再定义指向它的指针。若是实在不清楚应该指向何处，就把它初始化为nullptr或者0，这样程序就能检测并知道它没有指向任何具体的对象了。

 

赋值和指针

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

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

　　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指向的那个对象）发生改变

 

void*指针

　　　void*是一种特殊的指针类型，可用于存听任意对象的地址，一个void*指针存放着一个地址，这一点和其余指针相似，不一样的是，咱们对该地址中究竟是个什么类型的对象并不了解。

　　double obj = 3.14， *pd = &obj；

　　void *pv = &obj； //正确，void*能存听任意类型对象的地址   obj能够是任意类型的对象

　　pv = pd； //pv能够存听任意类型的指针。

　　利用void*指针能作的事情比较有限，拿它和别的指针比较，做为函数的输入和输出，或者赋值给另一个void*指针。不能直接操做void*指针所指的对象，由于咱们不知道这个对象究竟是什么类型，也就没法肯定能在这个对象上作哪些操做。

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

 

定义多个变量

　　常常有一种观点会误觉得，在定义语句中，类型修饰符（*或&）做用于本次定义的所有变量。形成这种错误见解的缘由有不少，其中之一就是咱们能够把空格写在类型修饰符和变量名中间。

　　int*  p；//合法可是容易产生误导

　　咱们说这种写法可能产生误导是由于int*放在一块儿好像是这条语句中全部变量共同的类型同样。其实偏偏相反，基本数据类型是int而非int*，*仅仅是修饰了p而已，对该声明语句中的其余变量，它并不产生任何做用。

　　int*  p1， p2； //p1是指向int的指针，p2是int

　　涉及指针或引用的声明，通常有两种写法，第一种把把修饰符和变量标识符写在一块儿。

　　int *p1， *p2；//p1，p2都是指向int的指针

　　这种形式着重强调变量具备的复合类型， 第二种把修饰符和类型名写在一块儿，而且每条语句只定义一个变量；

　　int*  p1；//p1是指向int的指针

　　int*  p2； //p2是指向int的指针

　　这种形式着重强调本次声明定义了一种复合类型。

　　我的推荐第一种写法。

 

指向指针的指针

　　通常来讲，声明符中修饰符的个数没有限制。当有多个修饰符写在一块儿的时候，按照其逻辑关系详加解释便可，以指针为例，指针是内存中的对象，像其余对象同样也有本身的地址，所以容许把指针的地址再存放到另外一个指针当中。

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

　　int ival = 1024；

　　int *pi = &ival； //pi是指向一个int型的数

　　int **ppi = &pi； //ppi是指向一个int型的指针

　　此处pi是指向int型的指针，而ppi是指向int型指针的指针，下图描述了他们之间的关系：

　　解引用int型指针会获得一个int型的数，一样，解引用指向指针的指针会获得一个指针，此时为了访问最原始的那个对象，须要对指针的指针作两次解引用；

　　cout << "The Value of ival\n"

　　　　<<"direct value: " << ival << "\n"

　　　　<<"indirect value: "<< *pi << "\n"

　　　　<<"doubly indirect value: " << **pi <<endl;

　　该程序使用三种不一样的方式输出了变量ival的值，第一种直接输出，第二种经过int型指针pi输出，第三种两次解引用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型指针。