再再论指针

最新推荐文章于 2020-08-29 10:50:56 发布

skyyunmi

最新推荐文章于 2020-08-29 10:50:56 发布

阅读量1.8k

点赞数

分类专栏：学习历程----C/C++ study 文章标签： c pointers 汇编 forms fun structure

学习历程----C/C++ study 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

再再论指针----篇首语

指针是 C 语言规范里面一项核心内容，指针具有与生俱来的优势，利用指针可以写出许多短小精悍、效率极高的代码，它是 C 语言一把无可替代的利器，凭着这把利器， C 语言与其它高级语言相比至少在效率方面高人一筹。但是，由于指针的原理与使用方式跟人们通常的思维习惯有较大的差别，造成了指针比 C 语言其它概念难理解得多，这使得对指针认识不足成为了一种在 C 程序员中普遍存在的现象，这种不足必然导致程序员在指针的使用过程中不断遭受挫折，挫折多了，指针俨然变成一道无法逾越的难关，恐惧感也就油然而生了。在恐惧感面前，某些程序员甚至产生了要避免使用指针的念头，这是非常不可取的。指针是如此犀利，正是它才使得 C 语言威猛无比，如果就这样把它放弃了，那么 C 语言就算是白学了。我们应当让指针成为你手中那把砍掉索伦手指上魔戒的举世无双的纳西尔圣剑，而不是成为你心中永远的魔戒。

本文的目的，是希望通过跟各位朋友一起讨论关于指针的几个关键概念及常见问题，以加深对指针的理解。因此，本文并不是讲述形如 int *p 、 struct {int i;float j;} *p 等这些东西是什么的文章，阅读本文的朋友最好对指针已经具有一定的使用经验，正因如此，笔者才给文章起名叫《再再论指针》。笔者不敢奢望能够完全解开你心中的魔结，但如果通过阅读本文，能够让你在日后的指针使用过程中减少失误，那笔者就心满意足了。本文将讨论如下十个主题，读者最好按主题的顺序一个一个地阅读，当然，如果你只对其中某个或某几个主题感兴趣，只看那几个也未尝不可。

当你阅读本文后：

如果你有不同的意见，欢迎你在评论里留下自己的见解，笔者很乐意跟你一起讨论，共同进步。

如果你觉得我说的全都是废话，那么恭喜你，你的指针已经毕业了。

如果你有太多不明白的地方，那么我介绍你先找一些关于数组与指针的读物看看，笔者推荐你阅读一本叫《 C 与指针》的书，看完后再回来继续思考你的问题。

1 、什么是数组名？----一个让你吃惊的事实！

2 、再一次吃惊！----数组的数组与多维数组的区别

3 、数组的解剖学

4 、 [ ]运算符的本质

5 、指向数组的指针

6 、 “另类”数组

7 、 C语言声明详解

8 、右左法则----复杂指针解析

9 、指针与const

10 、围绕p()与(*p)()的争论

11 、《再再论指针》后记 2005.10.17 日补充

第一章什么是数组名？----一个让你吃惊的事实！

数组是指针的基础，多数人就是从数组的学习开始指针的旅程的。下面我节选一些在各种论坛和文章里经常见到的关于数组的文字：
“ 一维数组是一级指针 ”
“ 二维数组是二级指针 ”
“ 数组名可以作为指针使用 ”
“ 数组名就是 .......... 的常量指针 ”
“ 数组名就是 .......... 的指针常量 ”
..................................
这些文字看起来非常熟悉吧？类似的文字还有许多，或许你就是经常说这些话的人呢。不过非常遗憾，这些文字都是错误的，实际上数组名永远都不会是指针！这个结论也许会让你震惊，但它的确是事实。数组名、指针、地址这几个概念虽然是基础中的基础，但它们恰恰是被混淆和滥用得最多的概念，把数组名说成指针，是一个概念性的错误，实质是混淆了指针与地址两个概念的本质。俗话说得好：浅水淹死人。因此，在讨论数组之前，有必要先回过头来澄清一下什么是指针，什么是地址，什么是数组名。

指针是 C 语言具有低级语言特征的最直接的证据。在汇编语言里面，指针的概念随处可见。比如 SP ， SP 寄存器又叫堆栈指针，它的值是地址，由于 SP 保存的是地址，并且 SP 的值是不断变化的，因此可以看作一个变量，而且是一个地址变量。地址也是 C 语言指针的值， C 语言的指针跟 SP 这样的寄存器虽然不完全一样，但原理却是相通的。 C 语言的指针也是一种地址变量， C89 明确规定，指针是一个保存对象地址的变量。这里要注意的是，指针跟地址概念的不同，指针是一种地址变量，通常也叫指针变量，统称指针。而地址则是地址变量的值。

看到这里，也许你会觉得，这么简单的东西还用你来说吗？的确，对于 p 与 &p 来说， 99% 的人都能在 0.1 秒内脱口而出谁是指针，谁是地址，但是，又有多少人在使用指针的过程中能够始终如一毫不动摇地遵循这两个概念呢？不少人使用指针的时候就会自觉或不自觉地把指针和地址两个概念混淆得一塌糊涂了，数组名的滥用就是一个活生生的例子。这一点甚至连一些经典著作也没能避免。

不过也不能全怪你自己，笔者认为某些国内教材应该承担最大的责任。这些教材一开始就没有给读者好好地分清指针与地址的区别，相反还在讲述的过程中有意无意地混用这两个概念。更有甚者，甚至在书中明言指针就是地址！说这话的家伙最应该在 C 语言这个地图上抹掉，呵呵。两个月前我在购书中心随手翻开了某个作者主编的一本被冠以国家 “ 十五 ” 规划重点研究项目的书，书里就是这么写的。当时笔者就感慨：不知道又要有多少人的思想被这家伙 “ 强奸 ” 了。

实际上，地址这个东西，本来就是一种基本数据类型，本应该在介绍整数、浮点、字符等基本类型的时候把地址显式地放在一起讨论，这样在后面介绍指针与数组的时候就能避免许多误解。可惜不少教材或者根本没有谈及，或者就算提起这个类型也用了指针类型这个字眼。这就错了，指针不是类型，真正的类型是地址，指针只是存储地址这种数据类型的变量！打个比方，对于
int i=10 ；
10 是整数，而 i 是存储整数的变量，指针就好比这个 i ，地址就好比那个 10 。指针能够进行加减法，原因并不是因为它是指针，加减法则不是属于指针这种变量的，而是地址这种数据类型的本能，正是因为地址具有加减的能力，所以才使指针作为存放地址的变量能够进行加减运算。这跟整数变量因为整数能够进行加减乘除因而它也能进行加减乘除一个道理。

那么数组名又应该如何理解呢？用来存放数组的区域是一块在栈中静态分配的内存 ( 非 static) ，而数组名是这块内存的代表，它被定义为这块内存的首地址。这就说明了数组名是一个地址，而且，还是一个不可修改的常量，完整地说，就是一个地址常量。数组名跟枚举常量类似，都属于符号常量。数组名这个符号，就代表了那块内存的首地址。注意了！不是数组名这个符号的值是那块内存的首地址，而是数组名这个符号本身就代表了首地址这个地址值，它就是这个地址，这就是数组名属于符号常量的意义所在。由于数组名是一种符号常量，因此它是一个右值，而指针，作为变量，却是一个左值，一个右值永远都不会是左值，那么，数组名永远都不会是指针！不管什么话，只要说数组名是一个指针的，都是错误的！就象把刚才 int i=10 例子中的 10 说成是整数变量一样，在最基本的立足点上就已经完错了。

总之要牢牢记住，数组名是一个地址，一个符号地址常量，不是一个变量，更不是一个作为变量的指针！

在数组名并非指针这个问题上，通常会产生两种疑问：
1 。作为形参的数组，不是会被转换为指针吗？
2 。如果形参是一个指针，数组名可以作为实参传递给那个指针，难道不是说明了数组名是一个指针吗？

首先， C 语言之所以把作为形参的数组看作指针，并非因为数组名可以转换为指针，而是因为当初 ANSI 委员会制定标准的时候，从 C 程序的执行效率出发，不主张参数传递时复制整个数组，而是传递数组的首地址，由被调函数根据这个首地址处理数组中的内容。那么谁能承担这种 “ 转换 ” 呢？这个主体必须具有地址数据类型，同时应该是一个变量，满足这两个条件的，非指针莫属了。要注意的是，这种 “ 转换 ” 只是一种逻辑看法上的转换，实际当中并没有发生这个过程，没有任何数组实体被转换为指针实体。另一方面，大家不要被 “ 转换 ” 这个字眼给蒙蔽了，转换并不意味着相同，实际上，正是因为不相同才会有转换，相同的话还转来干吗？这好比现在社会上有不少人 “ 变性 ” ，一个男人可以 “ 转换 ” 为一个女人，那是不是应该认为男人跟女人是相同的？这不是笑话么。

第二，函数参数传递的过程，本质上是一种赋值过程。 C89 对函数调用是这样规定的：函数调用由一个后缀表达式（称为函数标志符 ,function designator ）后跟由圆括号括起来的赋值表达式列表组成，在调用函数之前，函数的每个实际参数将被复制，所有的实际参数严格地按值传递。因此，形参实际上所期望得到的东西，并不是实参本身，而是实参的值或者实参所代表的值！举个例来说，对于一个函数声明：

void fun(int i);

我们可以用一个整数变量 int n 作实参来调用 fun ，就是 fun(n) ；当然，也正如大家所熟悉的那样，可以用一个整数常量例如 10 来做实参，就是 fun(10) ；那么，按照第二个疑问的看法，由于形参是一个整数变量，而 10 可以作为实参传递给 i ，岂不就说明 10 是一个整数变量吗？这显然是谬误。实际上，对于形参 i 来说，用来声明 i 的类型说明符 int ，所起的作用是用来说明需要传递给 i 一个整数，并非要求实参也是一个整数变量， i 真正所期望的，只是一个整数，仅此而已，至于实参是什么，跟 i 没有任何关系，它才不管呢，只要能正确给 i 传递一个整数就 OK 了。当形参是指针的时候，所发生的事情跟这个是相同的。指针形参并没有要求实参也是一个指针，它需要的是一个地址，谁能给予它一个地址？显然指针、地址常量和符号地址常量都能满足这个要求，而数组名作为符号地址常量正是指针形参所需要的地址，这个过程就跟把一个整数赋值给一个整数变量一样简单！

在后面的章节中，笔者将严格地使用地址这一概念，该是地址时就用地址，该是指针时就用指针，以免象其它教材那样给读者一个错误的暗示。

第二章再一次吃惊----数组的数组与多维数组的区别

看见这个题目，也许有些人就会嘀咕了：难道两者不是一样的吗？ C 语言的多维数组不就是数组的数组吗？不！两者是有区别的，而且还不小呢。首先看看两者的共同点：

1 。内存映象一样。

2 。数组引用方式一样，都是 “ 数组名 [ 下标 ][ 下标 ]........” 。

3 。数组名都是数组的首地址，都是一个符号地址常量、一个右值。

由于两者的共同点主要反映在外部表现形式上，因此，从外部看来，数组的数组跟多维数组似乎是一样的，这造成了 C 程序员对两者的区别长期以来模糊不清。但实际上， c 语言限于本身的语言特性，实现的并非真正的多维数组，而是数组的数组。

数组的数组与多维数组的主要区别，就在于数组的数组各维之间的内在关系是一种鲜明的层级关系。上一维把下一维看作下一级数组，也就是数组嵌套。数组引用时需要层层解析，直到最后一维。举个例，对于数组：
int a[7][8][9] ；
如果要访问元素 a[4][5][6] ，首先就要计算第一维元素 4 的地址，也就是 a+4 ，由于是数组的数组，元素 4 的值代表了一个数组，因此元素 4 的值就是它所代表的那个数组的首地址，我们用一个符号 address1 代表它，也就是 address1=*(a+4) ，接着计算第二维，显然元素 5 的地址是 address1+5 ，其值也是一个数组的首地址，用 address2 表示它，就是 address2=*(address1+5) ，最后一维，由于已经到达了具体的元素，因此这个元素的地址是 address2+6 ，其值 *(address2+6) 是一个整数，把 address1 和 address2 分别代入相应表达式，就成了：
*(*(*(a+4)+5)+6);
这就是我们熟知的 [] 运算符的等价表达式。

而真正的多维数组并没有这么多 “ 束缚 ” ，相比之下简单得多，由于各维之间不是这种复杂的层级关系，元素 a[4][5][6] 的偏移量可以这样直接获得： (4x8x9+5x9+6)xsizeof(int) ，再加上数组的首地址 a 就是元素 a[4][5][6] 的地址了。但是， c 语言的数组能够这样用首地址加上 (4x8x9+5x9+6)xsizeof(int) 的形式来访问元素吗？显然是不行的。归根到底就在于 C 语言的地址数据类型不但有类型，还具有级别。就是这种层级关系造成了 C 语言只能用数组的数组当作多维数组。如果 C 语言非得要实现真正的多维数组，那么地址与指针的概念就得重新改写了。

第三章数组的解剖学

这一章我们来讨论一下数组的内涵，对数组的内部构造进行一次解剖，看看里面究竟隐藏了什么秘密。有了前面两章对数组名和 C 语言数组本质的澄清，再来理解这一章的内容，就容易多了。

在下面的叙述中，笔者会用到一个运算符 sizeof ，由于在不同的编译器和编译模式下，对一个地址进行 sizeof 运算的结果有可能是不同的，为了方便讨论，我都假设地址长度为 4 个字节。

多数教材在讲述数组的时候，都是把重点放在外部表现形式上，很少涉及数组的内部，只告诉你如何做，却忽视了为什么要这样做。在解释的过程中，还会列出各种各样的表达式，例如： a 、 a+1 、 a[0] 、 a[0][0] 、 &a[0] 、 &a[0][0] 、 *(a+1) 等等，让人眼花缭乱。但实际上真正能够用来描述数组内部构造的表达式只有其中的几个。

上一章讲到， C 语言的数组实现并非真正的多维数组，而是数组嵌套，访问某个元素的时候，需要逐层向下解析。仍然以上一章的例子数组 int a[7][8][9] 来说，第一维元素 0 的值 a[0] 是 a[0] 所代表的那个数组的首地址，这个表达式在 C 语言的数组里面具有特殊的意义，之所以特殊，不仅仅在于它所代表的东西与一般的地址不同，而且类型也并非一般的地址类型，它的类型叫做数组类型，数组类型这个名称在绝大多数教材中是从来没有出现过的，在 C89 标准中，也仅仅出现在介绍数组定义的那一段。具有数组类型的地址跟一般类型地址的主要区别，在于长度不一样，对一个一般类型的地址进行 sizeof 运算，结果是 4 个字节，而 a[0] 由于代表了一个数组， sizeof(a[0]) 的结果是整个数组的长度 8x9xsizeof(int) ，并非 4 个字节。具有数组类型的地址跟数组名一样都是一个符号地址常量，因此它必定是一个右值。数组类型在数组的定义与引用中具有非常重要的作用，它可以用来识别一个标识符或表达式是否真正的数组，一个真正数组的数组名，是一个具有数组类型的符号地址常量，它的长度，是整个数组的长度，并非一般地址的长度，如果一个标识符不具备数组类型，那它就不是一个真正的数组。在后面的章节里，还会再次使用这个概念。

与 a[0] 类似的数组类型地址还有 a[0][0] ， a[0][0] 是 a[0] 的下一层数组，因此 sizeof(a[0][0]) 的结果是 9xsizeof(int) 。类似地，对于一个三维数组：

a[i][j][k]

a 、 a[x] 、 a[x][y] （其中 x 、 y 大于等于 0 而小于 i 、 j ）都是具有数组类型的地址常量，而且都是一个右值。这一点要牢牢记住。正是由这些特殊类型的地址构成了整个数组。

以上结论对于 n 维数组同样适用。

接下来跟各位一起讨论一下跟数组有关的各种表达式的意义及其类型：

&a[0][0][0] ：

&a[0][0][0] 仅仅是一个地址，它的意义，仅仅表示元素 a[0][0][0] 的地址， sizeof(&a[0][0][0]) 的结果是 4 。不少人把它说成是数组 a 的首地址，这是错误的，这是对数组首地址概念的滥用。真正能代表数组 a 的数组首地址只有 a 本身， a 与 &a[0][0][0] 的意义根本就是两回事，真正的数组首地址是具有数组类型的地址， sizeof(a) 结果是 ixjxkxsizeof(int) ，而不是 4 ，只不过由于 a[0][0][0] 位置特殊，恰好是数组 a 的第一个元素，所以它们的地址值才相同。而对于 a[0] 和 a[0][0] ，它们是在数组 a 内部 a[0] 和 a[0][0] 所代表的那个数组的首地址，它们的地址值也是由于位置 “ 特殊 ” ，因此才跟 a 和 &a[0][0][0] 一样。这一点一定要区分清楚了。

a+i ：

可能有些人会对 a+i 感到迷惑，数组的首地址加上一个整数是什么呢？它是第一维元素 i 的地址， sizeof(a+i) 为 4 。

a[i]+j ：

跟上面的类似， a[i]+j 是 a[i] 所代表的那个数组的元素 j 的地址， sizeof(a[i]+j) 的结果也为 4 。

&a ：

对数组名取地址在 C 标准里面是未定义的。这个表达式曾经引起过争论，焦点在于对一个右值取地址的合法性。 C89 规定 & 运算符的操作数必须具有具体的内存空间，换言之就是一个左值，但数组名却是一个右值，按照 & 运算符的要求，这是非法行为。因此，早期的编译器通常规定 &a 是非法的。但不知道什么原因，现在的编译器都把 &a 人为地定义成一个比 a 高一级而地址值跟 a 一样的地址，但作为比 a 高一级的地址，有一个行为却非常怪诞， sizeof(&a) 的结果跟 sizeof(a) 相同，这也是人为的痕迹。笔者倾向于把 &a 定义为非法，应该维护 & 运算符的权威性，而不是在规定对某个右值取地址为非法的同时，又允许对另一个右值取地址，这是互相矛盾的。

&a[i] 和 &a[i][j] ：

跟 &a 一样，也是未定义的，同样不符合 & 运算符的规则。由于 a[i] 是 a[i][j] 的上一层数组，有些人可能会想当然地以为： a[i]=&a[i][j] ，错也，实际上，由于 a[i][j]=*(a[i]+j) ，因此 &a[i][j]=&*(a[i]+j) ，结果是 a[i]+j 。对于 sizeof(&a[i]) 和 sizeof(&a[i][j]) ，由于是未定义的，因此有些编译器规定其值跟 sizeof(a[i]) 和 sizeof(a[i][j]) 相同，有些编译器却规定为 4 ，就是一个地址的长度。

第四章 [ ]运算符的本质

数组是存在于人们头脑中的一个逻辑概念，而编译器其实并不知道有数组这个东西，它所知道的，只是 [] 运算符，当遇到 [] 运算符的时候，编译器只是简单地把它转换为类似 *(*(a+i)+j) 这样的等价表达式，之所以是这种表达式，如前几章所述，是因为 C 语言的数组实现本质上是数组的嵌套。

由于这种等价关系的存在，会产生一些古零精怪的表达式，例如：

10[a]

这个表达式初看上去让人摸不着头脑，它是什么呢？如上所述，编译器会把它转换为 *(10+a) ，把 a 和 10 调换一下，就是 *(a+10) 了，这个就是 a[10] 。

[] 运算符之前还可以是一个表达式，例如： (10+20)[a] 。

严格来讲，以上两个表达式是非法的，因为 C89 对于数组的引用（注意不是数组定义）规定：带下标的数组引用后缀表达式由一个后缀表达式后跟一个括在方括号中的表达式组成。方括号前的后缀表达式的类型必须为 “ 指向 T 类型的指针 ” ，其中 T 为某种类型；方括号中表达式的类型必须为整型。这个规定说明，进行数组引用的时候， [] 运算符的左边并非必须为数组名，而可以是一个表达式，但这个表达式的类型必须为 “ 指向某类型的指针 ” 。显然 10 跟 (10+20) 连地址都不是，因此实际上他们是非法的，编译器在这里并没有严格遵守标准的规定。但如果是：

int a[10], *p = a;

(p+1)[2] 这样就是合法的，因为 p+1 的结果仍然是一个指针。

要注意的是，虽然后缀表达式是一个 “ 指向某类型的指针 ” ，但不要被这里所说的指针一词搞混了，上面的规定不能反过来使用。还是以上面的例子为例，我们可以 p[i] 这样使用 p ，这是符合上述规定的，但并不能因为指针 p 能够以 p[i] 这种形式使用就认为 p 是一个数组，这就错误了，不能反过来应用上述规则。

最后说一下编译器对 &* 的优化，对于数组 int a[10] ，如果对其中一个元素取地址，例如 &a[1] ，这条表达式等价于 &*(a+1) ，编译器并不会先计算 * 再运算 & ，而是对 &* 两个运算符进行优化，把它们同时去掉，因为两者的作用是相反的，最后得到计算的是 a+1 表达式。

第五章指向数组的指针

讲到第五章了，数组两个字还离不开我们的左右，数组的内容也真多，另一方面也因为数组与指针的关系的确非常密切。

通常，对于 int a[8][9] 这个二维数组，我们可以这样定义一个指向它的指针：

int (*p)[9];

这个声明的形式跟人们所熟悉的 int *p 的形式大相庭径，初学者通常会感到迷惑，不理解的地方大致有四个：

1 。为什么会以这种形式声明？

2 。 (*p) 应该如何理解？

3 。为什么必须把第二维显式地声明？

4 。为什么忽略第一维？

下面我们就一起逐个讨论这四个问题：

1 。这种形式是 C 标准的声明语法规定的，由于本章不是对标准的解释，只是对标准的应用，因此笔者尽量以简洁的方式解释这个声明，详细的讨论将在第七章进行。 C 标准的声明包含了两部分：

声明：

声明说明符初始化声明符表 opt (opt 的意思是可选 )

在声明说明符里面有一项类型说明符， int 就是这种类型说明符。而初始化声明符表里面的其中一种形式，就是：

直接声明符 [ 常量表达式 opt]

(*p)[9] 就是这种直接声明符加 [] 的形式。

2 。 p 左边的 * 在这里不是取值运算符，而是一个声明符，它指出 p 是一个指针。而 () 括号是不能去掉的，如果去掉了，由于 [] 运算符优先级比 * 高， p 就会先跟 [] 结合，这样 p 就变成了一个指针数组，而不是指向数组的指针。

题外话：

*p 还有一种用法，就是当 * 是取值运算符的时候， *p 是一个左值，表示一个变量，为什么 *p 是一个变量呢？也许有人会说，因为 int i, *p=&i 嘛，其实这是结果不是原因。严格来说， i 只是一个变量名，不是变量，在编译器的符号表里面，变量名是一个符号地址，它所代表的地址值是它指向的那段内存单元的地址，真正叫变量的是那段内存单元，懂汇编的朋友能很容易地区分出来，在汇编里面，可以这样定义一个变量名：

VARW DW 10,20

VARW 就是一个变量名，它在汇编里面是一个地址，代表了 10 所在的内存单元这个变量。由于 p 被初始化为 &i ， *p 指向 i 所代表的那段内存单元，因此说 *p 是一个变量。把 i 称为变量是一种习惯上的统称。

3 。定义一个指针的时候，首先必须定出指针的类型，由于这是一个指向数组的指针，如果数组的元素的类型定下来了，那么这个指针的类型也就定下来了。前面说过， C 语言的多维数组实质上是数组的嵌套，那么所指向数组的元素必定具有数组类型，也就是说，这个数组的元素是一个具有 6 个 int 元素的数组，因此， p 定义的时候，必须指定第二维的上界，这样才能把 p 的类型定下来。

4 。有这种疑问的人已经犯了一个错误，没有分清楚什么是指针，什么是数组，以数组的思维模式来看待这个指针 p 。定义一个数组（非 static ）的时候，需要在栈中静态分配一块内存，那么就需要知道这块内存的大小，因此定义数组时需要确定各维的上界。而这里只是定义一个指针而已，对于一个指针的定义，需要知道的是它所指向对象的类型，并不需要知道对象的大小，这是多余的。因此，所有指向数组的指针的第一维被忽略。

以上介绍了如何声明一个指向二维数组的指针，类似地，对一个指向 n 维数组的指针也可以用同样的方法来声明，如下：

int (*p)[x2][x3]......[xn];

同样可以忽略第一维，而其它维必须指定上界。

最后再讨论一种很常见的对多维数组的错误理解，有些人常常会以为，二维数组就是二级指针，这种错误的根源，来自于可以把一个二级指针 int **p 以 p[i][j] 这种形式使用。首先把数组称为指针就是错误的，第一章笔者已经说明了数组名是地址，不能理解为指针。第二，并非能以 p[i][j] 这种形式使用，那么 p 就是一个二维数组了， C 标准对数组引用的规定，并没有指定数组引用时 [] 运算符的左边必须是数组名，而可以是一个表达式。第三，这是一种 “ 巧合 ” ，归根到底是由于 C 语言的数组实现是数组的嵌套同时 C 标准把 [] 运算符转换为类似 *(*(a+i)+j) 这样的等价表达式造成的，那两个取值运算符 “ 恰好 ” 可以用于一个二级指针。第四， p 与 p[i] 并不具有数组类型， sizeof(p) 和 sizeof(p[i]) 的结果只是一个指针的大小 4 字节。而对于一个真正的数组， p 与 p[i] 都是具有数组类型的地址。

实际上， int **p 只是一个指向一维指针数组的指针，而不是指向二维数组的指针。同样地，对于 n 级指针，都可以看作一个指向一维指针数组的指针，这个指针数组的元素都是 n-1 级指针。

第六章 “另类”数组

动态数组与字符串常量可算是两种 “ 另类 ” 数组。

VLA 可变长数组并不为 C89 所支持， C99 才开始支持 VLA 。但如果想在只支持 C89 的编译环境中使用 VLA 的话，怎么办呢？我们可以用动态数组来 “ 模拟 ” ，动态数组在矩阵的运算中很常见，常用来向函数传递一个大小可变的矩阵。动态数组的原理，是利用一块或多块动态分配的内存存储各维的首地址，这样就可以 p[i][j] 的形式访问数组的数据了。但是，动态数组并非真正的数组，它只是对数组的一种模拟。由于具有数组类型的数组名是系统行为，在用户这一级没法做到，因此只能以指针的形式存放首地址， sizeof(p) 和 sizeof(p[i]) 结果都是 4 字节。虽然动态数组是依靠动态分配内存来建立的，但动态的意义并非来自这里，而是指大小可变。笔者觉得用 “ 动态数组 ” 这个名称来命名非常适合，既不失大小可变的特征，又可以跟 VLA 可变长数组区分开来。

下面是建立动态数组的示例：

#include <stdio.h>
#include <stdlib.h>

void computedata(int *, int, int);

int main(void)
{
        int iData[100], x, y;
        do
        {
                printf("The product obtained by multiplying x and y must be less than 100!");
                printf("x=");
                scanf("%d", &x);
                printf("y=");
                scanf("%d", &y);
        }
        while(x*y > 100);
        computedata(iData, x, y);
        return 0;
}

void computedata(int *ipSource, int iRow, int iColumn)
{
        int **ipTemp, i, j;
        ipTemp = (int **)malloc(iRow*sizeof(int*));
        for(i=0; i<iRow; ++i) ipTemp[i] = ipSource+i*iColumn;
        for(i=0; i<iRow; ++i) for(j=0; j<iColumn; ++j) ipTemp[i][j] += 1;
        free(ipTemp);
        return;
}

以上示例把动态数组 ipTemp 的元素都加了 1 ，由于只是示例，笔者省略了检测数据合法性的代码。 iRow 是第一维上界， iColumn 是第二维上界， iData 是源数据缓冲区， iRow*iColumn 的积不能超过 iData 缓冲区的大小，否则就会越界了，但可以比它小。示例中 iData 被定义为一维数组，当然根据自己的需要也可以用其它类型的缓冲区代替，例如动态分配的一块内存，或者多维数组，如果是多维数组，例如三维数组 int iData[10][10][10] ，调用 computedata 函数时，实参 iData 得做一些转换：

computedata((int *)iData, x, y); 或者 computedata(&iData[0][0][0], x, y); 都可以。

ipSource 指针用来传递缓冲区的首地址，这个指针由于要用来计算各维的地址，因此最好定义为一级指针，这样比较方便。 ipTemp 是一个二级指针，这是因为它指向的那块内存存放的是指针，这些指针指向各维的首地址，对 ipTemp 的元素来说， ipTemp 就是二级的。最后记得 free(ipTemp);

以上是定义一个二维动态数组的例子，多维动态数组的创建方法跟这个类似，下面给出三维动态数组的代码：

void computedata(int *ipSource, int iHigh, int iRow, int iColumn)
{
        int ***ipTemp, i, j, k;
        ipTemp = (int ***)malloc(iHigh*sizeof(int**));
        for(i=0; i<iHigh; ++i) ipTemp[i] = (int **)malloc(iRow*sizeof(int*));
        for(i=0; i<iHigh; ++i) for(j=0; j<iRow; ++j) ipTemp[i][j] = ipSource+i*iRow*iColumn+j*iColumn;
        for(i=0; i<iHigh; ++i) for(j=0; j<iRow; ++j) for(k=0; k<iColumn; ++k) ipTemp[i][j][k] += 1;
        for(i=0; i<iHigh; ++i) free(ipTemp[i]);
        free(ipTemp);
        return;
}

下面来讨论字符串常量。
众所周知， C 语言是没有字符串变量的，因而， C89 规定，字符串常量就是一个字符数组。因此，尽管字符串常量的外部表现形式跟数组完全不同，但它的确是一个真正的数组，实际上，字符串常量本身就是这个数组的首地址，并且具有数组类型，对一个字符串常量进行 sizeof 运算，例如 sizeof("abcdefghi") ，结果是 10 ，而不是 4 。字符串常量与一般数组的主要区别，是字符串常量存放在静态存储区，而一般数组（非 static ）则是在栈中静态分配的。由于字符串常量是数组首地址，因此可以数组引用的形式使用它，例如：

printf("%s", &"abcdefghi"[4]);

这将打印出字符串 efghi 。还可以这样：

printf("%s", "abcdefghi"+4);

同样打印出字符串 efghi 。实际上， &"abcdefghi"[4] 等价于 &*("abcdefghi"+4) ，去掉 &* 后，就是 "abcdefghi"+4 了。

我们可以利用字符串常量这些特性写出一些有趣的程序来，例如：

#include <stdio.h>

int iLine=1;

int main(void)
{
printf("%*s/n", 7-(iLine>4?iLine-4:4-iLine), "*******"+2*(iLine>4?iLine-4:4-iLine));
if(++iLine != 8) main();
return 0;
}

这个程序不使用任何数组形式的引用，不使用循环，就可以打印出用 * 号组合出来的菱形。当然，笔者并非鼓励大家编写这样的代码，但通过这样的例子加深对字符串常量的认识，仍然是非常重要的。

第七章 C语言声明详解

人们常说， C 语言的声明太复杂了，的确，这也是 C 语言饱受批评的地方之一。不过，笔者认为，真正要受到批评的不是语言本身，而是那些传播者。传播者们通常都有一个共识：讲述要由浅入深。作为原则，笔者并非要反对它，毕竟笔者对 C 语言的学习，也经历了相同的过程。但是，由浅入深并不意味着一切从简，以偏盖全。计算机语言不同于数学理论（虽然它的确根植于数学，与数学密不可分），数学理论是一种循序渐进的过程，后面的理论以前面的理论为基础。但 C 语言归根说底，就是一堆语言规则而已，应该让学习者一开始就全面且详细地了解它，而不是象现在某些教材所做的那样，只说一部分，不说另一部分，以为这就是由浅入深了，实际上这是以偏盖全。

语言如此，声明作为 C 语言的一部分更是如此。我们最常见到的对声明的描述是这样的：

存储类别类型限定词类型标识符

这种说明会给人们一种暗示： C 语言的声明是静止的、死板的，什么声明都能够以这个为基础，往上一套就 OK 了。事实真的如此吗？说句心里话，笔者也祈祷事实真的如此，这样世界就简单多了、清静多了。但别忘了，这个世界总是让人事与愿违的。实际上， C 的声明的组织形式是以嵌套为基础的，是用嵌套声明组织起来的，并非象上面所述那么死板，存储类说明符一定得放在限定词前面吗？类型说明符一定要紧贴标识符吗？不！ C 标准从来没有这样说过！下面来看一看 C89 对声明的形式是如何规定的：

声明：

声明说明符初始化声明符表 opt [opt 的意思是 option ，可选 ]

其中声明说明符由以下三项构成：

声明说明符：

存储类说明符声明说明符 opt
类型说明符声明说明符 opt
类型限定符声明说明符 opt

在这里，一个声明说明符可以包含另一个声明说明符，这就是声明的嵌套，这种嵌套贯穿于整个声明之中，今天我们看来一个非常简单的声明，其实就是由多个声明嵌套组成的，例如：

static const int i=10, j=20, k=30;

变量 i 前面就是声明说明符部分，有三个声明说明符： static const int ， static 是一个存储类说明符，它属于这种形式：

static 声明说明符

static 后面的声明说明符就是 const int ， const 是一个类型限定符，这也是个嵌套，它是由

const 声明说明符

组成，最后的 int 是一个类型说明符，到这里已经没有嵌套了， int 就是最底的一层。对于存储类说明符、类型说明符和类型限定符的排列顺序， C 标准并没有规定其顺序，谁嵌套谁都可以。换言之，上面的声明可以写成 :

int static const i=10, j=20, k=30; 或者 const int static i=10, j=20, k=30;

这无所谓，跟原声明是一样的。再举一个有趣的例子：

const int *p; 与 int const *p;

有些人会对后面一种形式感到困惑，因为他一直以来学习的都是那种死板的形式，因此他无法理解为什么那个 const 可以放在 int 的后面。实际上对于标准来说，这是再正常不过的行为了。

上面举的例子是变量的声明，函数的声明也同样道理，例如：

static const int func(void);
......

int main(void)
{
        int static const (*p)(void);
        p=func;
        .........
        return 0;
}

const int static func(void)
{
.......
return 0;
}

func 的函数原型声明、函数定义跟 main 内的函数指针 p 的声明是一样的。但是，笔者并非鼓励大家把声明说明符写得乱七八糟，作为一个良好的风格，应该按照已经习惯约定的方式排列说明符，但懂得其中的原理非常重要。

声明 static const int i=10, j=20, k=30; 的 int 后面的部分就是初始化声明符表，这比较容易理解，这个符表实际上也是嵌套的：

初始化声明符表：

初始化声明符
初始化声明符表，初始化声明符

初始化声明符：

声明符
声明符 = 初值

声明符是初始化声明符的主体，现在来讨论一下声明符是如何规定的：

声明符：

指针 opt 直接声明符

这里写的指针 opt 指的是那个指针声明符 * ，要注意的是， * 属于声明符，而不是声明说明符的一部分。

指针 opt 又包含：

指针：

* 类型限定符表 opt
* 类型限定符表 opt 指针

在这里有一个常见的问题，就是 const int *p; 与 int * const p 的区别，第一个声明的 const 属于声明说明符，它跟 int 一起，是用来说明 *p 这个声明符的，因此 const 修饰的是 p 所指向的那个对象，这个对象是 const 的。而第二个声明的 const 是声明符的一部分，它修饰的对象是 p 本身，因此 p 是 const 的。

上面规定的第二条值得注意，这条规定产生了一种指针与 const 的复杂形式，例如：

const int * const *** const ** const p; （是不是有种想冲向厕所的冲动？）这是一种复杂的声明嵌套，如何解读这种声明？其实只要掌握了它的规律，无论它有多少个 const 、多少个 * 都不难解读的，这个内容我将在第九章进行解释。

剩下的就是直接声明符和类型限定词表的内容：

直接声明符：

标识符
（声明符）
直接声明符 [ 常量表达式 opt]
直接声明符（形式参数类型表）
直接声明符（标识符表 opt ）

类型限定符表：

类型限定符
类型限定符表类型限定符

这一章的最后一个内容，是讨论一下 typedef ， typedef 用来声明一个别名， typedef 后面的语法，是一个声明。本来笔者以为这里不会产生什么误解的，但结果却出乎意料，产生误解的人不在少数。罪魁祸首又是那些害人的教材。在这些教材中介绍 typedef 的时候通常会写出如下形式：

typedef int PARA;

这种形式跟 #define int PARA 几乎一样，如前面几章所述，这些教材的宗旨是由浅入深，但实际做出来的行为却是以偏盖全。的确，这种形式在所有形式中是最简单的，但却没有对 typedef 进一步解释，使得不少人用 #define 的思维来看待 typedef ，把 int 与 PARA 分开来看， int 是一部分， PARA 是另一部分，但实际上根本就不是这么一回事。 int 与 PARA 是一个整体！就象 int i: 声明一样是一个整体声明，只不过 int i 定义了一个变量，而 typedef 定义了一个别名。这些人由于持有这种错误的观念，就会无法理解如下一些声明：

typedef int a[10];
typedef void (*p)(void);

他们会以为 a[10] 是 int 的别名， (*p)(void) 是 void 的别名，但这样的别名看起来又似乎不是合法的名字，于是陷入困惑之中。实际上，上面的语句把 a 声明为具有 10 个 int 元素的数组的类型别名， p 是一种函数指针的类型别名。

虽然在功能上， typedef 可以看作一个跟 int PARA 分离的动作，但语法上 typedef 属于存储类声明说明符，因此严格来说， typedef int PARA 整个是一个完整的声明。

第八章右左法则----复杂指针解析

上一章费那么多唇舌讨论 C 语言的声明，其实目的都是为了这一章，期望读者通过对 C 语言声明形式的详细了解，树立声明嵌套的观念，因为 C 语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是 C 标准里面的内容，它是从 C 标准的声明规定中归纳出来的方法。 C 标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的：

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

这段英文的翻译如下：

右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。

笔者要对这个法则进行一个小小的修正，应该是从未定义的标识符开始阅读，而不是从括号读起，之所以是未定义的标识符，是因为一个声明里面可能有多个标识符，但未定义的标识符只会有一个。

现在通过一些例子来讨论右左法则的应用，先从最简单的开始，逐步加深：

int (*func)(int *p);

首先找到那个未定义的标识符，就是 func ，它的外面有一对圆括号，而且左边是一个 * 号，这说明 func 是一个指针，然后跳出这个圆括号，先看右边，也是一个圆括号，这说明 (*func) 是一个函数，而 func 是一个指向这类函数的指针，就是一个函数指针，这类函数具有 int* 类型的形参，返回值类型是 int 。

int (*func)(int *p, int (*f)(int*));

func 被一对括号包含，且左边有一个 * 号，说明 func 是一个指针，跳出括号，右边也有个括号，那么 func 是一个指向函数的指针，这类函数具有 int * 和 int (*)(int*) 这样的形参，返回值为 int 类型。再来看一看 func 的形参 int (*f)(int*) ，类似前面的解释， f 也是一个函数指针，指向的函数具有 int* 类型的形参，返回值为 int 。

int (*func[5])(int *p);

func 右边是一个 [] 运算符，说明 func 是一个具有 5 个元素的数组， func 的左边有一个 * ，说明 func 的元素是指针，要注意这里的 * 不是修饰 func 的，而是修饰 func[5] 的，原因是 [] 运算符优先级比 * 高， func 先跟 [] 结合，因此 * 修饰的是 func[5] 。跳出这个括号，看右边，也是一对圆括号，说明 func 数组的元素是函数类型的指针，它所指向的函数具有 int* 类型的形参，返回值类型为 int 。

int (*(*func)[5])(int *p);

func 被一个圆括号包含，左边又有一个 * ，那么 func 是一个指针，跳出括号，右边是一个 [] 运算符号，说明 func 是一个指向数组的指针，现在往左看，左边有一个 * 号，说明这个数组的元素是指针，再跳出括号，右边又有一个括号，说明这个数组的元素是指向函数的指针。总结一下，就是： func 是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有 int* 形参，返回值为 int 类型的函数。

int (*(*func)(int *p))[5];

func 是一个函数指针，这类函数具有 int* 类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有 5 个 int 元素的数组。

要注意有些复杂指针声明是非法的，例如：

int func(void) [5];

func 是一个返回值为具有 5 个 int 元素的数组的函数。但 C 语言的函数返回值不能为数组，这是因为如果允许函数返回值为数组，那么接收这个数组的内容的东西，也必须是一个数组，但 C 语言的数组名是一个右值，它不能作为左值来接收另一个数组，因此函数返回值不能为数组。

int func[5](void);

func 是一个具有 5 个元素的数组，这个数组的元素都是函数。这也是非法的，因为数组的元素除了类型必须一样外，每个元素所占用的内存空间也必须相同，显然函数是无法达到这个要求的，即使函数的类型一样，但函数所占用的空间通常是不相同的。

作为练习，下面列几个复杂指针声明给读者自己来解析，答案放在第十章里。

int (*(*func)[5][6])[7][8];

int (*(*(*func)(int *))[5])(int *);

int (*(*func[7][8][9])(int*))[5];

实际当中，需要声明一个复杂指针时，如果把整个声明写成上面所示的形式，对程序可读性是一大损害。应该用 typedef 来对声明逐层分解，增强可读性，例如对于声明：

int (*(*func)(int *p))[5];

可以这样分解：

typedef int (*PARA)[5];
typedef PARA (*func)(int *);

这样就容易看得多了。

第九章指针与const

const 一词是英文 constant 的缩写，设立这个关键字的本意，是希望让它所修饰的对象成为一个常量。记得在国家间的外交中，有一个经常用到的术语： “ 从事与身份不符的活动 ” ，这个 const 恰恰也正从事着这样的活动，呵呵。 C 语言可以有三种方法定义一个常量： #define 、 const 和枚举，但只有枚举才是真正的常量，什么是真正的常量？真正的常量是没有存储空间的，是一个右值，这意味着通过任何合法的手段也不会被修改，但被 const 修饰的对象依然是一个左值，尽管这个对象被 const 限定，笔者仍然至少可以找到三种合法的手段去修改它，而 #define 所做的只不过是编译期替换而已，只有枚举常量才能真正做到这一点。 const 实在不应该被命名为 const ，这会让人们产生误解，它应该命名为 readonly 或类似的字眼，意即不能通过被 const 修饰的对象修改它所指向的对象或者它所代表的对象。但在 C 的世界里把 const 称为常量早已是普遍的现象，那我们就只好随大流咯，也称之为常量吧，只要知道它实际上不是真正的常量就行了。

第七章曾经讨论过 const int *p; 与 int * const p 的区别，这两个声明的中文名称常常搞得混乱不堪。第一个声明的 const 是声明说明符，它修饰 p 所指向的对象，但 p 仍然是可变的，这意味着 p 是一个指向常量的指针，简称常量指针。第二个声明的 const 是声明符的一部分，它修饰的对象是 p ，这意味着 p 是一个常量，而且是一个指针类型的常量，简称指针常量。指针常量又常常被人称为 “ 常指针 ” 或 “ 常指针变量 ” ，常指针变量这个名称有点蹩脚，又常又变的，容易让人摸不着头脑，最好还是不要这样称呼。这里还得再强调一次指针常量与地址常量是不同的，不能把数组名称为指针常量，也不能把指针常量称为地址常量，因为指针常量依然是一个左值，而数组名是一个右值，这里肯定有人会问： “ 什么？指针常量是一个左值？我没听错吧？ ” 你的确没有听错， C89 对于左值是这样定义的：

对象是一个命名的存储区域，左值（ lvalue ）是引用某个对象的表达式。

换言之，如果一个表达式引用的是一个具有具体存储空间的对象，它就是一个左值！那么既然指针常量是一个左值，为什么却不能给它赋值呢？是因为它受限于赋值表达式的一条规则：赋值表达式的左值不能含有限定词！

为了防止指针指向的常量被修改， C 标准对于指针间赋值有一个规定，就是左值必须包含右值的所有限定词。这就限定了一个指向 const 对象的指针不能赋值给指向非 const 对象的指针，但反过来就允许。这个规定初看上去非常合理，但其效用其实只限于一级指针，二级指针间的赋值即使满足规定也不再安全，下面举个例子：

const int i=10;
const int **p1;
int *p2;
p1 = &p2;
*p1 = &i;
*p2 = 20;

现在你会发现，作为常量的 i 的值被修改了。 i 的值被修改的关键原因在 *p1=&i; 这一句， &i 是一个指向常量的一级地址，如果没有二级指针 p1 ，受限于上述规定，作为左值接受这个一级地址的指针就必须也是一个指向常量的一级指针，于是就不能进行下一步赋值 20 的操作。因此，正由于指向 const 对象的二级指针 p1 的出现，使得 *p1 也是一个指向 const 的指针，于是 *p1=&i 能够合法地运行，常量 i 的值被修改也就成了一个预想中的结果了。有鉴于此，某些编译器也会限定非 const 二级指针之间的赋值，规定上面的 p1=&p2 也是非法的。

第七章介绍声明符的指针部分有一种形式：

* 类型限定符表 opt 指针

这种形式产生了一种比较复杂的带 const 的指针，例如：

const int * const *** const ** const p;

这是一个会让人头晕目眩的表达式，声明符部分嵌套了九次，如何辨认谁是 const ，谁不是 const 呢？一旦明白了其中的原则，其实是非常简单的。第一和最后一个 const 大家都已经很熟悉的了。对于藏在一堆 * 号中的 const ，有一个非常简单的原则： const 与左边最后一个声明说明符之间有多少个 * 号，那么就是多少级指针是 const 的。例如从右数起第二个 const ，它与 int 之间有 4 个 * 号，那么 p 的四级部分就是 const 的，下面的赋值表达式是非法的：

**p = (int *const***)10;
但下面的赋值是允许的：
***p=(int*const**)10;
从左边数起第二个 const ，它与 int 之间有 1 个 * ，那么 p 的一级部分是 const 的，也就是 *****p = (int*const***const*)10; 是非法的。

第十章围绕p()与(*p)()的争论

对于一个函数：

void func(void);

我们通常可以定义一个这样的函数指针指向它：

void (*p)(void) = func;

通过 p 调用 func 时，通常有两种写法：

p(); 或者 (*p)();

围绕这两种写法，当初 C89 制定的时候曾经有过争论。 (*p)(); 是一种旧式的规定，旧式规定圆括号左边必须具有 “ 函数 ” 类型，如果是指向函数的指针，那么必须加上 * 声明符。但 C89 不再把圆括号的左边限定为 “ 函数 ” 类型，而是一个后缀表达式。那么问题就来了，如果 p 的值是函数地址，那么 * 号就是声明符，但如果 p 指向的内容是函数地址， * 号就得被看作运算符了。同一种形式会有两种解释，这是一个矛盾。不仅函数调用如此，指向数组的指针也存在这种矛盾。编译器为了处理这种情况得增加代码，效率自然就降低了。争论的最后结果是谁也不能把对方完全说服，于是就干脆两种都支持了。笔者认为应该抛弃旧式的规定， p(); 这种形式简洁明了，又符合函数的一般形式，何乐而不为？

第八章练习的答案，同时给出用 typedef 的分解方法：

int (*(*func)[5][6])[7][8];

func 是一个指向数组的指针，这类数组的元素是一个具有 5X6 个 int 元素的二维数组，而这个二维数组的元素又是一个二维数组。

typedef int (*PARA)[7][8];
typedef PARA (*func)[5][6];

int (*(*(*func)(int *))[5])(int *);

func 是一个函数指针，这类函数的返回值是一个指向数组的指针，所指向数组的元素也是函数指针，指向的函数具有 int* 形参，返回值为 int 。

typedef int (*PARA1)(int*);
typedef PARA1 (*PARA2)[5];
typedef PARA2 (*func)(int*);

int (*(*func[7][8][9])(int*))[5];

func 是一个数组，这个数组的元素是函数指针，这类函数具有 int* 的形参，返回值是指向数组的指针，所指向的数组的元素是具有 5 个 int 元素的数组。

typedef int (*PARA1)[5];
typedef PARA1 (*PARA2)(int*);
typedef PARA2 func[7][8][9];

《再再论指针》后记

在这篇后记中，笔者将对三个问题进行补充：

一、关于数组名取地址的问题。 c89 、 c99 允许对数组名取地址，是由于数组符合一个对象的定义，按照一

个对象的语义，对其取地址是合理的。但矛盾在于，数组名是一个符号地址，是一个右值，对其取地址不

符合 & 运算符的语法。 c89 、 c99 委员会经过权衡，认为维护一个对象的合理性比一个运算符更重要、更合

理，因此允许对数组名取地址。但是， &a 的意义，已经不是对一个数组名取地址，而是对一个数组对象取

地址，因此， &a 所代表的地址值才跟 a 地址值一样，同时 sizeof(&a) 应该等于 sizeof(a) 。 c89 、 c99 对这个

观点是这样阐述的：

Some implementations have not allowed the & operator to be applied to an array or a function.(The construct was permitted in early versions of C, then later made optional.) The C89 Committee endorsed the construct since it is unambiguous, and since data abstraction is enhanced by allowing the important & operator to apply uniformly to any addressable entity.

二、对于二级 const 指针间的赋值，笔者曾经在第九章举了一个例子，以说明二级 const 指针间的赋值会导

致一个常量被修改。这里再补充一条理由。以 const int *p1 和 int *p2 为例类型比较涉及两个方面。首先， p1

和 p2 所指向的对象都是 int ，这是相容的； p1 带有 const 而 p2 没有，这也是相容的，因为它符合 “ 指针间赋

值左值要包含右值所有的限定词 ” 这条规则。但对于 const int ** p1 和 int **p2 来说，情况就不一样了。虽然

p1 仍然符合 “ 左值包含右值所有限定词 ” 规则，但 p1 所指向的对象是一个指向 const 对象的指针，而 p2 所指

向的对象却是一个指向非 const 对象的指针，两者的类型不相容，因此 p1=p2 非法。这条理由是一种已过时

的现象，更多地存在于早期的编译器里，由于它往往让用户难以理解，因此后期的编译器都倾向于允许这种

赋值。

三、关于 p() 与 (*p)() 之间的争论，有人提出，由于 c89 存在一条隐含声明，会使得 p() 这种形式存在危险

性。

首先， c89 、 c99 推荐使用 p() 这种形式已经是盖棺定论的事实，两个标准是这样说的：

Pointers to functions may be used either as (*pf)() or as pf(). The latter construct, not sanctioned in K&R, appears in some present versions of C, is unambiguous, invalidates no old code, and can be an important shorthand. The shorthand is useful for packages that present only one external name, which designates a structure full of pointers to objects and functions: member functions can be called as graphics.open(file) instead of (*graphics.open)(file).
...........................
The C89 Committee saw no real harm in allowing these forms; outlawing forms like (*f)(), while still permitting *a for a[], simply seemed more trouble than it was worth.

可见 (*p)() 这种形式是 K&R 时代的旧式规定， c89 、 c99 仍然支持它只不过是因为对旧代码的支持。

第二，这些人以为，未声明 p 而使用 p() 的时候，由于这条隐含声明的存在， p 就是已被声明了，这是对隐

含声明的错误理解，实际上 c89 、 c99 只是把这种情况下的 p() 当作 extern int p(); 而已，在语法上， p 仍

然是一个未声明的标识符！它违反了另一条规则：一个标识符应当在声明之后才能使用。但它不应该象其

它未声明标识符那样产生一条 error ，否则隐含声明跟不存在没有什么两样。它应该产生一条 warning ，以

说明 p 是 undefined 或者函数原型未声明。

如果一定要说会产生什么问题的话，那就是可能会有某些程序员忽略这个 warning ，这会产生一些问题。

但这是设计者的原因，不是标准的原因。出于杜绝这种隐患的原因， c99 干脆废除了 c89 的隐含声明，以使

编译器产生一条 error 。 c99 关于这一点是这样说的：

The rule for implicit declaration of functions has been removed in C99.The effect is to guarantee the production of a diagnostic that will catch an additional category of programming errors.

第四点写于 11 月 8 日