说到指针，不少编程爱好者都止不住摇头叹息，这块内容是编程体系中的重点，但又是难点。即使是编程大牛，使用指针的时候也有可能出错，甚至出现无法预料的情况。但我们又不得不学习，下面来一起看看C++指针有哪些需要掌握的知识。

　　数组

　　前面说了在C++中是通过变量来对内存进行访问的，但根据前面的说明，C++中只能通过变量来操作内存，也就是说要操作某块内存，就必须先将这块内存的首地址和一个变量名绑定起来，这是很糟糕的。比如有100块内存用以记录100个工人的工资，现在要将每个工人的工资增加5%，为了知道各个工人增加了后的工资为多少，就定义一个变量float a1;，用其记录第1个工人的工资，然后执行语句a1 += a1 * 0.05f;，则a1里就是增加后的工资。由于是100个工人，所以就必须有100个变量，分别记录100个工资。因此上面的赋值语句就需要有100条，每条仅仅变量名不一样。

　　上面需要手工重复书写变量定义语句float a1;100遍（每次变一个变量名），无谓的工作。因此想到一次向操作系统申请100*4=400个字节的连续内存，那么要给第i个工人修改工资，只需从首地址开始加上4*i个字节就行了（因为float占用4个字节）。

　　为了提供这个功能，C++提出了一种类型--数组。数组即一组数字，其中的各个数字称作相应数组的元素，各元素的大小一定相等（因为数组中的元素是靠固定的偏移来标识的），即数组表示一组相同类型的数字，其在内存中一定是连续存放的。在定义变量时，要表示某个变量是数组类型时，在变量名的后面加上方括号，在方括号中指明欲申请的数组元素个数，以分号结束。因此上面的记录100个工资的变量，即可如下定义成数组类型的变量：

　　float a[100];

　　上面定义了一个变量a，分配了100*4=400个字节的连续内存（因为一个float元素占用4个字节），然后将其首地址和变量名a相绑定。而变量a的类型就被称作具有100个float类型元素的数组。即将如下解释变量a所对应内存中的内容（类型就是如何解释内存的内容）：a所对应的地址标识的内存是一块连续内存的首地址，这块连续内存的大小刚好能容纳下100个float类型的数字。

　　因此可以将前面的float b;这种定义看成是定义了一个元素的float数组变量b。而为了能够访问数组中的某个元素，在变量名后接方括号，方括号中放一数字，数字必须是非浮点数，即使用二进制原码或补码进行表示的数字。如a[ 5 + 3 ] += 32;就是数组变量a的第5 + 3个元素的值增加32。又：

　　long c = 23; float b = a[ ( c - 3 ) / 5 ] + 10, d = a[ c - 23 ];

　　上面的b的值就为数组变量a的第4个元素的值加10，而d的值就为数组变量a的第0个元素的值。即C++的数组中的元素是以0为基本序号来记数的，即a[0]实际代表的是数组变量a中的第一个元素的值，而之所以是0，表示a所对应的地址加上0*4后得到的地址就为第一个元素的地址。

　　应该注意不能这样写：long a[0];，定义0个元素的数组是无意义的，编译器将报错，不过在结构或类或联合中符合某些规则后可以这样写，那是C语言时代提出的一种实现结构类型的长度可变的技术，在《C++从零开始（九）》中将说明。

　　还应注意上面在定义数组时不能在方括号内写变量，即long b = 10; float a[ b ];是错误的，因为编译此代码时，无法知道变量b的值为多少，进而无法分配内存。可是前面明明已经写了b = 10;，为什么还说不知道b的值？那是因为无法知道b所对应的地址是多少。因为编译器编译时只是将b和一个偏移进行了绑定，并不是真正的地址，即b所对应的可能是Base - 54，而其中的Base就是在程序一开始执行时动态向操作系统申请的大块内存的尾地址，因为其可能变化，故无法得知b实际对应的地址（实际在Windows平台下，由于虚拟地址空间的运用，是可以得到实际对应的虚拟地址，但依旧不是实际地址，故无法编译时期知道某变量的值）。

　　但是编译器仍然可以根据前面的long b = 10;而推出Base - 54的值为10啊？重点就是编译器看到long b = 10;时，只是知道要生成一条指令，此指令将10放入Base - 54的内存中，其它将不再过问（也没必要过问），故即使才写了long b = 10;编译器也无法得知b的值。

　　上面说数组是一种类型，其实并不准确，实际应为--数组是一种类型修饰符，其定义了一种类型修饰规则。关于类型修饰符，后面将详述。

　　字符串

　　在《C++从零开始（二）》中已经说过，要查某个字符对应的ASCII码，通过在这个字符的两侧加上单引号，如'A'就等同于65。而要表示多个字符时，就使用双引号括起来，如："ABC"。而为了记录字符，就需要记录下其对应的ASCII码，而ASCII码的数值在-128到127以内，因此使用一个char变量就可以记录一个ASCII码，而为了记录"ABC"，就很正常地使用一个char的数组来记录。如下：

　　char a = 'A'; char b[10]; b[0] = 'A'; b[1] = 'B'; b[2] = 'C';

　　上面a的值为65，b[0]的值为65，b[1]为66，b[2]为67。因为b为一个10元素的数组，在这其记录了一个3个字符长度的字符串，但是当得到b的地址时，如何知道其第几个元素才是有效的字符？如上面的b[4]就没有赋值，那如何知道b[4]不应该被解释为字符？可以如下，从第0个元素开始依次检查每个char元素的值，直到遇到某个char元素的值为0（因为ASCII码表中0没有对应的字符），则其前面的所有的元素都认为是应该用ASCII码表来解释的字符。故还应b[3] = 0;以表示字符串的结束。

　　上面的规则被广泛运用，C运行时期库中提供的所有有关字符串的操作都是基于上面的规则来解释字符串的（关于C运行时期库，可参考《C++从零开始（十九）》）。但上面为了记录一个字符串，显得烦琐了点，字符串有多长就需要写几个赋值语句，而且还需要将末尾的元素赋值为0，如果搞忘则问题严重。对于此，C++强制提供了一种简写方式，如下：

　　char b[10] = "ABC";

　　上面就等效于前面所做的所有工作，其中的"ABC"是一个地址类型的数字（准确的说是一初始化表达式，在《C++从零开始（九）》中说明），其类型为char[4]，即一个4个元素的char数组，多了一个末尾元素用于放0来标识字符串的结束。应当注意，由于b为char[10]，而"ABC"返回的是char[4]，类型并不匹配，需要隐式类型转换，但实际没有进行转换，而是做了一系列的赋值操作（就如前面所做的工作），这是C++硬性规定的，称为初始化，且仅仅对于数组定义时进行初始化有效，即如下是错误的：

　　char b[10]; b = "ABC";

　　而即使是char b[4]; b = "ABC";也依旧错误，因为b的类型是数组，表示的是多个元素，而对多个元素赋值是未定义的，即：float d[4]; float dd[4] = d;也是错误的，因为没定义d中的元素是依次顺序放到dd中的相应各元素，还是倒序放到，所以是不能对一个数组类型的变量进行赋值的。

　　由于现在字符的增多（原来只用英文字母，现在需要能表示中文、日文等多种字符），原来使用char类型来表示字符，最多也只能表示255种字符（0用来表示字符串结束），所以出现了所谓的多字节字符串（MultiByte），用这种表示方式记录的文本文件称为是MBCS格式的，而原来使用char类型进行表示的字符串称为单字节字符串（SingleByte），用这种表示方式记录的文本文件称为是ANSI格式的。

　　由于char类型可以表示负数，则当从字符串中提取字符时，如果所得元素的数值是负的，则将此元素和下一个char元素联合起来形成一short类型的数字，再按照Unicode编码规则（一种编码规则，等同于前面提过的ASCII码表）来解释这个short类型的数字以得到相应的字符。

　　而上面的"ABC"返回的就是以多字节格式表示的字符串，因为没有汉字或特殊符号，故好象是用单字节格式表示的，但如果：char b[10] = "AB汉C";，则b[2]为-70，b[5]为0，而不是想象的由于4个字符故b[4]为0，因为“汉”这个字符占用了两个字节。

　　上面的多字节格式的坏处是每个字符的长度不固定，如果想取字符串中的第3个字符的值，则必须从头开始依次检查每个元素的值而不能是3乘上某个固定长度，降低了字符串的处理速度，且在显示字符串时由于需要比较检查当前字符的值是否小于零而降低效率，故又推出了第三种字符表示格式：宽字节字符串（WideChar），用这种表示方式记录的文本文件称为是Unicode格式的。其与多字节的区别就是不管这个字符是否能够用ASCII表示出来，都用一个short类型的数字来表示，即每个字符的长度固定为2字节，C++对此提供了支持。

　　short b[10] = L"AB汉C";

　　在双引号的前面加上“L”（必须是大写的，不能小写）即告诉编译器此双引号内的字符要使用Unicode格式来编码，故上面的b数组就是使用Unicode来记录字符串的。同样，也有：short c = L'A';，其中的c为65。

　　如果上面看得不是很明白，不要紧，在以后举出的例子中将会逐渐了解字符串的使用的。

　　静态和动态

　　上面依然没有解决根本问题--C++依旧只能通过变量这个映射元素来访问内存，在访问某块内存前，一定要先建立相应的映射，即定义变量。有什么坏处？让我们先来了解静态和动态是什么意思。

　　收银员开发票，手动，则每次开发票时，都用已经印好的发票联给客人开发票，发票联上只印了4个格子用以记录商品的名称，当客人一次买的商品超过4种以上时，就必须开两张或多张发票。这里发票联上的格子的数量就被称作静态的，即无论任何时候任何客人买东西，开发票时发票联上都印着4个记录商品名称用的格子。

　　超市的收银员开发票，将商品名称及数量等输入电脑，然后即时打印出一张发票给客人，则不同的客人，打印出的发票的长度可能不同（有的客人买得多而有的少），此时发票的长度就称为动态的，即不同时间不同客人买东西，开出的发票长度可能不同。

　　程序无论执行多少遍，在申请内存时总是申请固定大小的内存，则称此内存是静态分配的。前面提出的定义变量时，编译器帮我们从栈上分配的内存就属于静态分配。每次执行程序，根据用户输入的不同而可能申请不同大小的内存时，则称此内存是动态分配的，后面说的从堆上分配就属于动态分配。

　　很明显，动态比静态的效率高（发票长度的利用率高），但要求更高--需要电脑和打印机，且需要收银员的素质较高（能操作电脑），而静态的要求就较低，只需要已经印好的发票联，且也只需收银员会写字即可。

　　同样，静态分配的内存利用率不高或运用不够灵活，但代码容易编写且运行速度较快；动态分配的内存利用率高，不过编写代码时要复杂些，需自己处理内存的管理（分配和释放）且由于这种管理的介入而运行速度较慢并代码长度增加。

　　静态和动态的意义不仅仅如此，其有很多的深化，如硬编码和软编码、紧耦合和松耦合，都是静态和动态的深化。

　　地址

　　前面说过“地址就是一个数字，用以唯一标识某一特定内存单元”，而后又说“而地址就和长整型、单精度浮点数这类一样，是数字的一种类型”，那地址既是数字又是数字的类型？不是有点矛盾吗？如下：

　　浮点数是一种数--小数--又是一种数字类型。即前面的前者是地址实际中的运用，而后者是由于电脑只认识状态，但是给出的状态要如何处理就必须通过类型来说明，所以地址这种类型就是用来告诉编译器以内存单元的标识来处理对应的状态。

　　指针

　　已经了解到动态分配内存和静态分配内存的不同，现在要记录用户输入的定单数据，用户一次输入的定单数量不定，故选择在堆上分配内存。假设现在根据用户的输入，需申请1M的内存以对用户输入的数据进行临时记录，则为了操作这1M的连续内存，需记录其首地址，但又由于此内存是动态分配的，即其不是由编译器分配（而是程序的代码动态分配的），故未能建立一变量来映射此首地址，因此必须自己来记录此首地址。

　　因为任何一个地址都是4个字节长的二进制数（对32位操作系统），故静态分配一块4字节内存来记录此首地址。检查前面，可以将首地址这个数据存在unsigned long类型的变量a中，然后为了读取此1M内存中的第4个字节处的4字节长内存的内容，通过将a的值加上4即可获得相应的地址，然后取出其后连续的4个字节内存的内容。但是如何编写取某地址对应内存的内容的代码呢？前面说了，只要返回地址类型的数字，由于是地址类型，则其会自动取相应内容的。但如果直接写：a + 4，由于a是unsigned long，则a + 4返回的是unsigned long类型，不是地址类型，怎么办？

　　C++对此提出了一个操作符--“*”，叫做取内容操作符（实际这个叫法并不准确）。其和乘号操作符一样，但是它只在右侧接数字，即*( a + 4 )。此表达式返回的就是把a的值加上4后的unsigned long数字转成地址类型的数字。但是有个问题：a + 4所表示的内存的内容如何解释？即取1个字节还是2个字节？以什么格式来解释取出的内容？如果自己编写汇编代码，这就不是问题了，但现在是编译器代我们编写汇编代码，因此必须通过一种手段告诉编译器如何解释给定的地址所对内存的内容。

　　C++对此提出了指针，其和上面的数组一样，是一种类型修饰符。在定义变量时，在变量名的前面加上“*”即表示相应变量是指针类型（就如在变量名后接“[]”表示相应变量是数组类型一样），其大小固定为4字节。如：

　　unsigned long *pA;

　　上面pA就是一个指针变量，其大小因为是为32位操作系统编写代码故为4字节，当*pA;时，先计算pA的值，就是返回从pA所对应地址的内存开始，取连续4个字节的内容，然后计算“*”，将刚取到的内容转成unsigned long的地址类型的数字，接着计算此地址类型的数字，返回以原码格式解释其内容而得到一个unsigned long的数字，最后计算这个unsigned long的数字而返回以原码格式解释它而得的二进制数。

　　也就是说，某个地址的类型为指针时，表示此地址对应的内存中的内容，应该被编译器解释成一个地址。

　　因为变量就是地址的映射，每个变量都有个对应的地址，为此C++又提供了一个操作符来取某个变量的地址--“&”，称作取地址操作符。其与“数字与”操作符一样，不过它总是在右侧接数字（而不是两侧接数字）。

　　“&”的右侧只能接地址类型的数字，它的计算（Evaluate）就是将右侧的地址类型的数字简单的类型转换成指针类型并进而返回一个指针类型的数字，正好和取内容操作符“*”相反。

　　上面正常情况下应该会让你很晕，下面释疑。

　　unsigned long a = 10, b, *pA; pA = &a; b = *pA; ( *pA )++;

　　上面的第一句通过“*pA”定义了一个指针类型的变量pA，即编译器帮我们在栈上分配了一块4字节的内存，并将首地址和pA绑定（即形成映射）。然后“&a”由于a是一个变量，等同于地址，所以“&a”进行计算，返回一个类型为unsigned long*（即unsigned long的指针）的数字。

　　应该注意上面返回的数字虽然是指针类型，但是其值和a对应的地址相同，但为什么不直接说是unsigned long的地址的数字，而又多一个指针类型在其中搅和？因为指针类型的数字是直接返回其二进制数值，而地址类型的数字是返回其二进制数值对应的内存的内容。因此假设上面的变量a所对应的地址为2000，则a;将返回10，而&a;将返回2000。

　　看下指针类型的返回值是什么。当书写pA;时，返回pA对应的地址（按照上面的假设就应该是2008），计算此地址的值，返回数字2000（因为已经pA = &a;），其类型是unsigned long*，然后对这个unsigned long*的数字进行计算，直接返回2000所对应的二进制数（注意前面红字的内容）。

　　再来看取内容操作符“*”，其右接的数字类型是指针类型或数组类型，它的计算就是将此指针类型的数字直接转换成地址类型的数字而已（因为指针类型的数字和地址类型的数字在数值上是相同的，仅仅计算规则不同）。所以：

　　b = *pA;

　　返回pA对应的地址，计算此地址的值，返回类型为unsigned long*的数字2000，然后“*pA”返回类型unsigned long的地址类型的数字2000，然后计算此地址类型的数字的值，返回10，然后就只是简单地赋值操作了。同理，对于++( *pA )（由于“*”的优先级低于前缀++，所以加“()”），先计算“*pA”而返回unsigned long的地址类型的数字2000，然后计算前缀++，最后返回unsigned long的地址类型的数字2000。

　　如果你还是未能理解地址类型和指针类型的区别，希望下面这句能够有用：地址类型的数字是在编译时期给编译器用的，指针类型的数字是在运行时期给代码用的。如果还是不甚理解，在看过后面的类型修饰符一节后希望能有所帮助。

　　在堆上分配内存

　　前面已经说过，所谓的在堆上分配就是运行时期向操作系统申请内存，而要向操作系统申请内存，不同的操作系统提供了不同的接口，具有不同的申请内存的方式，而这主要通过需调用的函数原型不同来表现（关于函数原型，可参考《C++从零开始（七）》）。由于C++是一门语言，不应该是操作系统相关的，所以C++提供了一个统一的申请内存的接口，即new操作符。如下：

　　unsigned long *pA = new unsigned long; *pA = 10;

　　unsigned long *pB = new unsigned long[ *pA ];

　　上面就申请了两块内存，pA所指的内存（即pA的值所对应的内存）是4字节大小，而pB所指的内存是4*10=40字节大小。应该注意，由于new是一个操作符，其结构为new <类型名>[<整型数字>]。它返回指针类型的数字，其中的<类型名>指明了什么样的指针类型，而后面方括号的作用和定义数组时一样，用于指明元素的个数，但其返回的并不是数组类型，而是指针类型。

　　应该注意上面的new操作符是向操作系统申请内存，并不是分配内存，即其是有可能失败的。当内存不足或其他原因时，new有可能返回数值为0的指针类型的数字以表示内存分配失败。即可如下检测内存是否分配成功。

　　unsigned long *pA = new unsigned long[10000];

　　if( !pA )

　　? // 内存失败！做相应的工作

　　上面的if是判断语句，下篇将介绍。如果pA为0，则!pA的逻辑取反就是非零，故为逻辑真，进而执行相应的工作。

　　只要分配了内存就需要释放内存，这虽然不是必须的，但是作为程序员，它是一个良好习惯（资源是有限的）。为了释放内存，使用delete操作符，如下：

　　delete pA; delete[] pB;

　　注意delete操作符并不返回任何数字，但是其仍被称作操作符，看起来它应该被叫做语句更加合适，但为了满足其依旧是操作符的特性，C++提供了一种很特殊的数字类型--void。其表示无，即什么都不是，这在《C++从零开始（七）》中将详细说明。因此delete其实是要返回数字的，只不过返回的数字类型为void罢了。

　　注意上面对pA和pB的释放不同，因为pA按照最开始的书写，是new unsigned long返回的，而pB是new unsigned long[ *pA ]返回的。所以需要在释放pB时在delete的后面加上“[]”以表示释放的是数组，不过在VC中，不管前者还是后者，都能正确释放内存，无需“[]”的介入以帮助编译器来正确释放内存，因为以Windows为平台而开发程序的VC是按照Windows操作系统的方式来进行内存分配的，而Windows操作系统在释放内存时，无需知道欲释放的内存块的长度，因为其已经在内部记录下来（这种说法并不准确，实际应是C运行时期库干了这些事，但其又是依赖于操作系统来干的，即其实是有两层对内存管理的包装，在此不表）。

　　类型修饰符（type-specifier）

　　类型修饰符，即对类型起修饰作用的符号，在定义变量时用于进一步指明如何操作变量对应的内存。因为一些通用操作方式，即这种操作方式对每种类型都适用，故将它们单独分离出来以方便代码的编写，就好像水果。吃苹果的果肉、吃梨的果肉，不吃苹果的皮、不吃梨的皮。这里苹果和梨都是水果的种类，相当于类型，而“XXX的果肉”、“XXX的皮”就是用于修饰苹果或梨这种类型用的，以生成一种新的类型--苹果的果肉、梨的皮，其就相当于类型修饰符。

　　本文所介绍的数组和指针都是类型修饰符，之前提过的引用变量的“&”也是类型修饰符，在《C++从零开始（七）》中将再提出几种类型修饰符，到时也将一同说明声明和定义这两个重要概念，并提出声明修饰符（decl-specifier）。

　　类型修饰符只在定义变量时起作用，如前面的unsigned long a, b[10], *pA = &a, &rA = a;。这里就使用了上面的三个类型修饰符--“[]”、“*”和“&”。上面的unsigned long暂且叫作原类型，表示未被类型修饰符修饰以前的类型。下面分别说明这三个类型修饰符的作用。

　　数组修饰符“[]”--其总是接在变量名的后面，方括号中间放一整型数c以指明数组元素的个数，以表示当前类型为原类型c个元素连续存放，长度为原类型的长度乘以c。因此long a[10];就表示a的类型是10个long类型元素连续存放，长度为10*4=40字节。而long a[10][4];就表示a是4个long[10]类型的元素连续存放，其长度为4*40=160字节。

　　相信已经发现，由于可以接多个“[]”，因此就有了计算顺序的关系，为什么不是10个long[4]类型的元素连续存放而是倒过来？类型修饰符的修饰顺序是从左向右进行计算的。故short *a[10];表示的是10个类型为short*的元素连续存放，长度为10*4=40字节。

　　指针修饰符“*”--其总是接在变量名的前面，表示当前类型为原类型的指针。故：

　　short a = 10, *pA = &a, **ppA = &pA;

　　注意这里的ppA被称作多级指针，即其类型为short的指针的指针，也就是short**。而short **ppA = &pA;的意思就是计算pA的地址的值，得一类型为short*的地址类型的数字，然后“&”操作符将此数字转成short*的指针类型的数字，最后赋值给变量ppA。

　　如果上面很昏，不用去细想，只要注意类型匹配就可以了，下面简要说明一下：假设a的地址为2000，则pA的地址为2002，ppA的地址为2006。

　　对于pA = &a;。先计算“&a”的值，因为a等同于地址，则“&”发挥作用，直接将a的地址这个数字转成long*类型并返回，然后赋值给pA，则pA的值为2000。

　　对于ppA = &pA;。先计算“&pA”的值，因为pA等同于地址，则“&”发挥作用，直接将pA的地址这个数字转成long**类型（因为pA已经是long*的类型了）并返回，然后赋值给ppA，则ppA的值为2002。

　　引用修饰符“&”--其总是接在变量名的前面，表示此变量不用分配内存以和其绑定，而在说明类型时，则不能有它，下面说明。由于表示相应变量不用分配内存以生成映射，故其不像上述两种类型修饰符，可以多次重复书写，因为没有意义。且其一定在“*”修饰符的右边，即可以long **&a = ppA;但不能long *&*a;或long &**a;因为按照从左到右的修饰符计算顺序，long*&*表示long的指针的引用的指针，引用只是告知编译器不要为变量在栈上分配内存，实际与类型无关，故引用的指针是无意义的。而long&**则表示long的引用的指针的指针，同上，依旧无意义。同样long &a[40];也是错误的，因为其表示分配一块可连续存放类型为long的引用的40个元素的内存，引用只是告知编译器一些类型无关信息的一种手段，无法作为类型的一种而被实例化（关于实例化，请参看《C++从零开始（十）》）。

　　应该注意引用并不是类型（但出于方便，经常都将long的引用称作一种类型），而long **&rppA = &pA;将是错误的，因为上句表示的是不要给变量rppA分配内存，直接使用“=”后面的地址作为其对应的地址，而&pA返回的并不是地址类型的数字，而是指针类型，故编译器将报类型不匹配的错误。但是即使long **&rppA = pA;也同样失败，因为long*和long**是不同的，不过由于类型的匹配，下面是可以的（其中的rpA2很令人疑惑，将在《C++从零开始（七）》中说明）：

　　long a = 10, *pA = &a, **ppA = &pA, *&rpA1 = *ppA, *&rpA2 = *( ppA + 1 );

　　类型修饰符和原类型组合在一起以形成新的类型，如long*&、short *[34]等，都是新的类型，应注意前面new操作符中的<类型名>要求写入类型名称，则也可以写上前面的long*等，即：

　　long **ppA = new long*[45];

　　即动态分配一块4*45=180字节的连续内存空间，并将首地址返回给ppA。同样也就可以：

　　long ***pppA = new long**[2];

　　而long *(*pA)[10] = new long*[20][10];

　　也许看起来很奇怪，其中的pA的类型为long *(*)[10]，表示是一个有10个long*元素的数组的指针，而分配的内存的长度为(4*10)*20=800字节。因为数组修饰符“[]”只能放在变量名后面，而类型修饰符又总是从左朝右计算，则想说明是一个10个long元素的数组的指针就不行，因为放在左侧的“*”总是较右侧的“[]”先进行类型修饰。故C++提出上面的语法，即将变量名用括号括起来，表示里面的类型最后修饰，故：long *(a)[10];等同于long *a[10];，而long *(&aa)[10] = a;也才能够正确，否则按照前面的规则，使用long *&aa[10] = a;将报错（前面已说明原因）。而long *(*pA)[10] = &a;也就能很正常地表示我们需要的类型了。因此还可以long *(*&rpA)[10] = pA;以及long *(**ppA)[10] = &pA;。

　　限于篇幅，还有部分关于指针的讨论将放到《C++从零开始（七）》中说明，如果本文看得很晕，后面在举例时将会尽量说明指针的用途及用法，希望能有所帮助。