主要素材是c99的文档,有一些cpp的内容但不是很全面,cpp的类型
声明和c的相比还是多了很多东西的,名字空间(namespace)、静态多
态类型(template)等都带来很多不同于c的新的课题,理解不是很深,
所以只好舍弃了。
从一个问题开始:怎么分析
typedef int (*PF) (const char *, const char *);
PF Register(PF pf);
跟
int (*Register (int (*pf)(const char *, const char *)))
(const char *, const char *);
是相同的声明。
1. 类型、类型检查和类型描述
说这两个是相同的声明的一种准确解释是两者具有相同的`类型
描述符'(type descriptor),类型描述是编译器用来表示标识符以及
表达式的类型的数据结构。
cpp的typeinfo可以理解为类型描述符的一种具体形式,c不支持类型
描述,虽然编译器里必须保存这个信息,但并没有提供给程序员。
这里刚好可以用typeinfo来检验题目中的两个声明类型上是等价的:
// 文件:d.cpp,用vc编译
#include <stdio.h>
#include <typeinfo>
typedef int (*PF) (const char *, const char *);
PF Register_1(PF pf);
int (*Register_2 (int (*pf)(const char *, const char *)))
(const char *, const char *);
int main()
{
printf("typeof(Register_1) is --/n%s/n", typeid(Register_1).name());
printf("typeof(Register_2) is --/n%s/n", typeid(Register_2).name());
return 0;
}
gcc的typeof扩展使得程序员可以间接的使用类型描述:
int (*PF) (const char *, const char *);
typeof(PF) (*Register)(typeof(PF));
有点背景知识是,c++里面,每个标识符、表达式都有一个类型,
编译器需要知道这个类型才能执行类型检查,类型检查的含义很
丰富,通俗的说,编译器发现:
int a;
char *b;
a=b;
会报错(vc 7.1):
c.cpp(5) : error C2440: “=” : 无法从“char *”转换为“int”
该转换要求 reinterpret_cast、C 样式转换或函数类型转换
这个错误就是编译的类型检查阶段发出的,因为编译器能够发现
标识符a和表达式b的类型不匹配,不能执行赋值。很明显,编译
器需要一个数据结构来存储,这个数据结构就是所谓的类型描述
的具体化,理解这个数据结构的作用和编码方式对于理解c的类型
声明是很有帮助的。
2. 类型和语法的关系
首先容易理解,类型最终来源于标识符的声明(declaration, 包括
定义即definition,定义是一种特殊的声明),因为表达式的类型
是根据其中包含的标识符和操作符(函数调用可以看作一种用户
自定义的操作符)来确定的。所以,说到底分析类型要从分析声
明语句开始。
类型,作为标识符和表达式的一个重要属性,和语法结构的其它
属性一样,完全是由程序的静态内容,主要是语法,决定的(有的
语言的类型是在运行时确定的,不过c和cpp都不是这样)。实际上,
c和cpp的有些声明之所以难以分析,主要是语法上的困难,pascal
的声明语法简单的多,相应的,很少有来自pascal程序员的类似抱怨。
3. c的声明
3.1 基本类型
c的类型有两种:基本类型(fundamental type)、导出类型(derived
type)。基本类型包括各种数值类型、void等,基本类型的声明很
简单:
int a; /*读作:type of identifier `a' is `int' */
float b; /*读作:type of identifier `b' is `float' */
_Bool c; /*读作:type of identifier `c' is `_Bool' */
_Complex d;/*读作:type of identifier `d' is `_Complex' */
等都是基本类型声明。_Bool/_Complex是一个c99中提到的标准类
型,不过我只看到gcc支持。注释中提到的`读作...',是为了便于和
下面分析导出类型的方法一致。
上述几个类型声明的语法可以写成EBNF的形式,这是我们得到的
最简单的类型声明,后面几个例子会稍微复杂一些,
declaration : type-specifier identifier
意思是一个declaration可以由一个type-specifier后面跟个identifier
组成。常用的extern、static、typedef、auto、register等称为storage
class specifier,c的语法规定它们可以和type-specifier出现在同样的
位置。即:
extern int a;
static int b;
等,这样得到的语法实际上是:
declaration : declaration-specifiers identifier
declaration-specifiers : (type-specifier | storage-class-specifier)*
第二个语法表达式中,`|'表示选择,即type-specifier、storage-
class-specifier都可以出现在这个位置,后面的*表示之前的语法
成分可以重复出现0到n次,看上去有些奇怪,但这的确是c99
类型声明语法的一部分。眼尖的话,应该能看出上面居然允许
一个类型声明中出现多个type-specifier,也就是说:
int double char a;
居然在语法上是正确的(当然语法上正确并不保证程序是正确的,
类型检查会出错),我的理解是这是为了简化语法分析程序的设计,
考虑到``long int''等类型声明(correct me?)。更奇怪的是,下面
居然是一个合法的类型声明,可以用gcc编译通过:
int int double char float;
只有一个警告,呵呵,跑题了,不过我想这个例子说明了精确的
定义实际一个可用的语言是件很辛苦的事情。
在declaration-specifier位置上还可以摆放一个标准的东西,即
const/volatile,通常称为`cv-qualifier'。
vc的编译器的扩展__declspec(naked/dllexport/dllimport)等等,
在语法上和上述type-spec/storage-class-specc是处于同等位置的,
我们从微软为这个语法元素取的名字上就能(事后诸葛亮的)猜出来。
c和cpp实际上还允许这样的声明:
int a=5;
也就是声明的时候指定变量的初始值,这个语法并不是很难理解,
而且初始化的部分不影响标识符的类型。考虑到这个因素,声明
的语法实际上要作如下改造:
declaration : declaration-specifiers init-declarator
declaration-specifiers : (type-specifier | storage-class-specifier)*
init-declarator : declarator | declarator '=' initializer
declarator是个有点抽象的东西,用来表示在类型构造中间阶段的
语法结构,cpp draft 96专门花了一章来讲述这个,上面
int a;
中`a'就是一个declarator,实际上就是由于这个东西使得c和cpp
的类型声明有时候变的很难懂,不像pascal,所有的类型声明都
是:
identifier : type-name ';'
这样的形式。declarator麻烦的地方在于它可以通过组合的方式
变的很复杂,见下面关于derived type的部分。另外一个麻烦的
地方在于ansi-c和cpp在函数的参数列表里允许使用所谓abstract
declarator,也就是不出现identifier的类型声明:
int f(int /* an abstract-declarator in which the identifier is ommited*/);
多说一句,实际上可以在一个声明里说明多个标识符,所以上面
init-declarator其实应该是init-declarator-list,不过这并不是很关键。
现在可以考虑如何用什么数据结构编码基本类型的描述符了,显然,
基本类型的描述符可以用一个枚举常数表示:
enum basic_type{
int_type,
float_type,
...
};
3.2 导出类型
3.2.1 简单导出类型
导出类型在cpp的文档里称为compound type(组合类型),这个概念
是递归定义的,是基本类型和组合类型通过类型组合得到的类型。
组合有几种形式:数组、函数、指针、引用、类、联合、枚举,
这些称为type constructor,可以不是很恰当的翻译为`类型构造子'。
最容易造成分析困难的组合是数组、指针和函数,尤其是这些组合
混合运用的时候。三者的语法分别可以简写为:
declarator:
| pointer declarator /* 指针声明的语法 */
| declarator '[' constant_expr ']' /* 数组声明的语法 */
| declarator '(' parameter_identifier_list ')' /* 函数声明的语法 */
上面有意忽略了一些情况,例如不说明长度的数组`int a[]',带abstract
declarator的参数列表的函数:`int f(int,float)'等,也没有说明指针和数组、
函数声明的优先级。实际上指针声明的优先级比函数、数组的优先级低,
所以要声明指向数组、函数的指针的时候,需要用括号把指针声明括起来:
int (*f)(int a);
首先就最简单的情况来看,关于:
int *a;
的含义,显然是:
typeof(a)=POINTER(INT)--------(1)
POINTER(INT)的含义希望可以不用解释,就像pascal的`^int'一样,这种
表示其实和指针类型的类型描述已经很接近了,大家可以参考一下gcc
的文档中表示types的数据结构的介绍。
也可以把这个理解分为两步:
typeof(*a)=int---------(2.1)
利用一个不难理解的等价变换(可以看作公理):
typeof(*xxx)=yyy ==> typeof(xxx)=POINTER(yyy) ----------(公理1)
得到:
typeof(a)=POINTER(int)------(2.2)
也就是说,把类型声明看成一个方程,typeof(a)是个要求的未知数,利用
一些等价变换的关系得到。看上去似乎有些多余,马上可以看到,后面这
种方法的好处是在多个type constructor的时候不容易想错。上面的公理1
是个重点,类似的还有:
typeof(xxx[yyy])=zzz; =>
typeof(xxx) = ARRAY(zzz); -----(公理2)
typeof(xxx(t1 a, t2 b))=yyy; =>
typeof(xxx)=FUNCTION(yyy; t1, t2); ------(公理3)
其中ARRAY(zzz)表示长度为zzz的数组,FUNCTION(yyy;t1,t2)表示返回值为
yyy类型,参数依次为t1、t2类型的函数,zzz/yyy/t1/t2都是类型变量。
3.2.2 复杂导出类型
多个type constructor的时候,困难在于声明的语法。看这个之前,
我觉得我们可以参考一下数学表达式的分析:
5+3 ---------(1)
3+3*6 -------(2)
b=3, a = 1 ? 3<<4+-3 : c = ~a++ | 2; --------- (3)
(3)显然不是那种一眼就能知道结果的表达式,虽然估计不会有人写出
那样风格的代码来,仔细观察一下可以发现,(3)的分析困难来源于:
*) 前缀、后缀、中缀、distfix运算符的混用
*) 一元、二元、三元运算符的混用
*) `-'号同时作为前缀操作符和中缀操作符
其中`distfix运算符'是指那些操作符散布在操作数当中的情况,c的
` ? : ' 就是典型的distfix运算符。
如果把类型声明也看成是表达式的话,复杂类型声明的分析困难
实际上和这个很类似。指针、引用的标志`*'、`&'相当于一元前缀
运算符,数组和函数的标志`['、`]'、`('、`)'相当于后缀运算符。
而`('、`)'既用来界定函数参数列表,又用来override优先级限制。
还好,倒是没有distfix的运算符。
和算术表达式类似,优先级在分析类型声明的时候也起到了很大
的作用。c语法规定,在类型声明表达式中,指针和引用的优先级
低,数组、函数以及表示override优先级的`('和`)'的优先级是同样
的。
所以:
int * f[5];
和
int *(f[5]);
等价,表示f是个数组,其元素是int指针,而若想表示指向int数组
的指针,则必须用括号来override这个优先级,也就是这么写:
int (*f)[5];
下面的cpp程序可以验证这一点:
// c.cpp, 用vc编译
#include <typeinfo>
#include <stdio.h>
int main()
{
int *f[5];
int *(g[5]);
int (*h)[5];
printf("%s/n", typeid(f).name());
printf("%s/n", typeid(g).name());
printf("%s/n", typeid(h).name());
return 0;
}
类似的:
int * f ();
和
int * (f());
等价,而和
int (*f)();
则不等价。
btw,把类型声明看成表达式的观点还可以和类型描述的概念很
好的结合起来:编译器求值这个表达式,得到一个类型描述,正
如人或者程序求值算术表达式得到一个数值结果一样。但是如上
所述,一个重要的区别是,类型声明表达式的分析需要类似解方
程的技巧。
继续说语法,形式语言的理论和实践已经形成很多有效的算法来
作这件事情,但对程序员来说,那些算法都有些枯燥,实际上更
多的还是靠直觉和试错。这里有个好消息是,c和cpp的语法都是
基本没有二义性的,也就是说除了极少的几个情况,只要我们能
分析出类型声明的一种语法结构,那么就可以放心的使用这个结
构来解释类型声明的含义,c标准委员会的专家们会保证不会有第
二种解释。就像下面的分析表现的那样,直觉、试错的缺点就是
不严格,但是多加练习、熟练之后就很有效了(试想一下,有哪
个小学毕业生不会凭直觉分析复杂的数学表达式?)
拿:
int (*Register (int (*pf)(const char *, const char *)))
(const char *, const char *);
作例子,首先把前面的`int'拿掉,因为显然这是一个type-specifier,
把后面的declarator部分记为:declarator-1,即:
declarator-1=(*Register (int (*pf)(const char *, const char *))) /
(const char *, const char *)
现在我们已经可以写出:
typeof(declarator-1)=INT ------------------------(1)
一旦我们分析出declarator-1的内部的结构,我们就可以按照前面的三个
公理来改写这个式子并最终得到整个类型声明的含义。ok,现在开始分
析declarator-1,很明显,declarator-1由两段括号括起来的部分组成,
先看末尾的一串括号括起来的东西:
(const char *, const char *)
我们意识到这里要出现一个function type constructor(不然还能是什么?),
令declarator-2表示剩下的部分,即:
declarator-2=(*Register (int (*pf)(const char *, const char *)))
结合1,由于:
declarator-1=declarator-2 (const char *, const char *)
所以现在我们可以写出:
typeof(declarator-2 (const char *, const char *))=INT
于是根据公理3,我们有:
typeof(declarator-2)=FUNCTION(INT; const char *, const char *); ----(2)
意思是declarator-2的类型是返回值为int,带两个类型为const char *
类型的参数的函数。其中`const char *'也许写成`POINTER((CONST(CHAR)))'
更合乎前面的习惯一些。
继续,declarator-2外头有一对括号,这个可不是表示函数类型构造,
而是保护Register前面的`*'的,按照c的语法的定义,分析到这个地步,
这样的括号是可以扔掉的。现在类型声明所要定义的标识符已经暴露
出来了,就是`Register',它前面是pointer,后面的一对括号表示函数
构造,即:`* A (B)'的形式,这里优先级就要起作用了,参看前面的例
子,因为函数构造的优先级高,所以函数声明部分先和Register结合,
再和`*'结合,令:
declarator-3=Register (int (*pf)(const char *, const char *))
这样:
declarator-2=( * declarator-3 )
根据(2),以及公理(1),有:
typeof(declarator-3)=POINTER(FUNCTION(int; const char *, const char *))
这样太罗嗦了,我们把等式右面的东西简写为PF,即:
PF=POINTER(FUNCTION(int; const char *, const char *))
typeof(declarator-3)=PF
再来分析declarator-3的结构,很简单,是个函数声明
typeof(Register (int (*pf)(const char *, const char *)))=PF
根据公理(3):
typeof(Register)=FUNCTION(PF; typeof(int (*pf)(const char *, const char *))));
而:typeof(int (*pf)(const char *, const char *)))这个类型表达式可以
按照和刚才完全一样的思路分析,巧了,刚好也等于已经分析过的PF:
typeof(int (*pf)(const char *, const char *)))=PF
这样,最后的结果就出来了:
typeof(Register)=FUNCTION(PF; PF)
4. 总结
和pascal的类型声明相比,c的类型声明的语法的确复杂了一些,甚至有点
让人疑心是完全没必要的复杂,尤其是考虑到可以通过引入typedef(类似
pascal的type equivalence语句)简化类型声明。不过为了阅读现有代码,
还是要适应这种情况的。
c的类型声明的难点在于类型构造的组合应用的情形,对这种情况,只要
成功的分析出其语法结构,就可以按照一种机械的方式翻译出所声明的
类型。语法分析的方法类似算术表达式的分析,需要考虑不同类型构造
的优先级。
声明和c的相比还是多了很多东西的,名字空间(namespace)、静态多
态类型(template)等都带来很多不同于c的新的课题,理解不是很深,
所以只好舍弃了。
从一个问题开始:怎么分析
typedef int (*PF) (const char *, const char *);
PF Register(PF pf);
跟
int (*Register (int (*pf)(const char *, const char *)))
(const char *, const char *);
是相同的声明。
1. 类型、类型检查和类型描述
说这两个是相同的声明的一种准确解释是两者具有相同的`类型
描述符'(type descriptor),类型描述是编译器用来表示标识符以及
表达式的类型的数据结构。
cpp的typeinfo可以理解为类型描述符的一种具体形式,c不支持类型
描述,虽然编译器里必须保存这个信息,但并没有提供给程序员。
这里刚好可以用typeinfo来检验题目中的两个声明类型上是等价的:
// 文件:d.cpp,用vc编译
#include <stdio.h>
#include <typeinfo>
typedef int (*PF) (const char *, const char *);
PF Register_1(PF pf);
int (*Register_2 (int (*pf)(const char *, const char *)))
(const char *, const char *);
int main()
{
printf("typeof(Register_1) is --/n%s/n", typeid(Register_1).name());
printf("typeof(Register_2) is --/n%s/n", typeid(Register_2).name());
return 0;
}
gcc的typeof扩展使得程序员可以间接的使用类型描述:
int (*PF) (const char *, const char *);
typeof(PF) (*Register)(typeof(PF));
有点背景知识是,c++里面,每个标识符、表达式都有一个类型,
编译器需要知道这个类型才能执行类型检查,类型检查的含义很
丰富,通俗的说,编译器发现:
int a;
char *b;
a=b;
会报错(vc 7.1):
c.cpp(5) : error C2440: “=” : 无法从“char *”转换为“int”
该转换要求 reinterpret_cast、C 样式转换或函数类型转换
这个错误就是编译的类型检查阶段发出的,因为编译器能够发现
标识符a和表达式b的类型不匹配,不能执行赋值。很明显,编译
器需要一个数据结构来存储,这个数据结构就是所谓的类型描述
的具体化,理解这个数据结构的作用和编码方式对于理解c的类型
声明是很有帮助的。
2. 类型和语法的关系
首先容易理解,类型最终来源于标识符的声明(declaration, 包括
定义即definition,定义是一种特殊的声明),因为表达式的类型
是根据其中包含的标识符和操作符(函数调用可以看作一种用户
自定义的操作符)来确定的。所以,说到底分析类型要从分析声
明语句开始。
类型,作为标识符和表达式的一个重要属性,和语法结构的其它
属性一样,完全是由程序的静态内容,主要是语法,决定的(有的
语言的类型是在运行时确定的,不过c和cpp都不是这样)。实际上,
c和cpp的有些声明之所以难以分析,主要是语法上的困难,pascal
的声明语法简单的多,相应的,很少有来自pascal程序员的类似抱怨。
3. c的声明
3.1 基本类型
c的类型有两种:基本类型(fundamental type)、导出类型(derived
type)。基本类型包括各种数值类型、void等,基本类型的声明很
简单:
int a; /*读作:type of identifier `a' is `int' */
float b; /*读作:type of identifier `b' is `float' */
_Bool c; /*读作:type of identifier `c' is `_Bool' */
_Complex d;/*读作:type of identifier `d' is `_Complex' */
等都是基本类型声明。_Bool/_Complex是一个c99中提到的标准类
型,不过我只看到gcc支持。注释中提到的`读作...',是为了便于和
下面分析导出类型的方法一致。
上述几个类型声明的语法可以写成EBNF的形式,这是我们得到的
最简单的类型声明,后面几个例子会稍微复杂一些,
declaration : type-specifier identifier
意思是一个declaration可以由一个type-specifier后面跟个identifier
组成。常用的extern、static、typedef、auto、register等称为storage
class specifier,c的语法规定它们可以和type-specifier出现在同样的
位置。即:
extern int a;
static int b;
等,这样得到的语法实际上是:
declaration : declaration-specifiers identifier
declaration-specifiers : (type-specifier | storage-class-specifier)*
第二个语法表达式中,`|'表示选择,即type-specifier、storage-
class-specifier都可以出现在这个位置,后面的*表示之前的语法
成分可以重复出现0到n次,看上去有些奇怪,但这的确是c99
类型声明语法的一部分。眼尖的话,应该能看出上面居然允许
一个类型声明中出现多个type-specifier,也就是说:
int double char a;
居然在语法上是正确的(当然语法上正确并不保证程序是正确的,
类型检查会出错),我的理解是这是为了简化语法分析程序的设计,
考虑到``long int''等类型声明(correct me?)。更奇怪的是,下面
居然是一个合法的类型声明,可以用gcc编译通过:
int int double char float;
只有一个警告,呵呵,跑题了,不过我想这个例子说明了精确的
定义实际一个可用的语言是件很辛苦的事情。
在declaration-specifier位置上还可以摆放一个标准的东西,即
const/volatile,通常称为`cv-qualifier'。
vc的编译器的扩展__declspec(naked/dllexport/dllimport)等等,
在语法上和上述type-spec/storage-class-specc是处于同等位置的,
我们从微软为这个语法元素取的名字上就能(事后诸葛亮的)猜出来。
c和cpp实际上还允许这样的声明:
int a=5;
也就是声明的时候指定变量的初始值,这个语法并不是很难理解,
而且初始化的部分不影响标识符的类型。考虑到这个因素,声明
的语法实际上要作如下改造:
declaration : declaration-specifiers init-declarator
declaration-specifiers : (type-specifier | storage-class-specifier)*
init-declarator : declarator | declarator '=' initializer
declarator是个有点抽象的东西,用来表示在类型构造中间阶段的
语法结构,cpp draft 96专门花了一章来讲述这个,上面
int a;
中`a'就是一个declarator,实际上就是由于这个东西使得c和cpp
的类型声明有时候变的很难懂,不像pascal,所有的类型声明都
是:
identifier : type-name ';'
这样的形式。declarator麻烦的地方在于它可以通过组合的方式
变的很复杂,见下面关于derived type的部分。另外一个麻烦的
地方在于ansi-c和cpp在函数的参数列表里允许使用所谓abstract
declarator,也就是不出现identifier的类型声明:
int f(int /* an abstract-declarator in which the identifier is ommited*/);
多说一句,实际上可以在一个声明里说明多个标识符,所以上面
init-declarator其实应该是init-declarator-list,不过这并不是很关键。
现在可以考虑如何用什么数据结构编码基本类型的描述符了,显然,
基本类型的描述符可以用一个枚举常数表示:
enum basic_type{
int_type,
float_type,
...
};
3.2 导出类型
3.2.1 简单导出类型
导出类型在cpp的文档里称为compound type(组合类型),这个概念
是递归定义的,是基本类型和组合类型通过类型组合得到的类型。
组合有几种形式:数组、函数、指针、引用、类、联合、枚举,
这些称为type constructor,可以不是很恰当的翻译为`类型构造子'。
最容易造成分析困难的组合是数组、指针和函数,尤其是这些组合
混合运用的时候。三者的语法分别可以简写为:
declarator:
| pointer declarator /* 指针声明的语法 */
| declarator '[' constant_expr ']' /* 数组声明的语法 */
| declarator '(' parameter_identifier_list ')' /* 函数声明的语法 */
上面有意忽略了一些情况,例如不说明长度的数组`int a[]',带abstract
declarator的参数列表的函数:`int f(int,float)'等,也没有说明指针和数组、
函数声明的优先级。实际上指针声明的优先级比函数、数组的优先级低,
所以要声明指向数组、函数的指针的时候,需要用括号把指针声明括起来:
int (*f)(int a);
首先就最简单的情况来看,关于:
int *a;
的含义,显然是:
typeof(a)=POINTER(INT)--------(1)
POINTER(INT)的含义希望可以不用解释,就像pascal的`^int'一样,这种
表示其实和指针类型的类型描述已经很接近了,大家可以参考一下gcc
的文档中表示types的数据结构的介绍。
也可以把这个理解分为两步:
typeof(*a)=int---------(2.1)
利用一个不难理解的等价变换(可以看作公理):
typeof(*xxx)=yyy ==> typeof(xxx)=POINTER(yyy) ----------(公理1)
得到:
typeof(a)=POINTER(int)------(2.2)
也就是说,把类型声明看成一个方程,typeof(a)是个要求的未知数,利用
一些等价变换的关系得到。看上去似乎有些多余,马上可以看到,后面这
种方法的好处是在多个type constructor的时候不容易想错。上面的公理1
是个重点,类似的还有:
typeof(xxx[yyy])=zzz; =>
typeof(xxx) = ARRAY(zzz); -----(公理2)
typeof(xxx(t1 a, t2 b))=yyy; =>
typeof(xxx)=FUNCTION(yyy; t1, t2); ------(公理3)
其中ARRAY(zzz)表示长度为zzz的数组,FUNCTION(yyy;t1,t2)表示返回值为
yyy类型,参数依次为t1、t2类型的函数,zzz/yyy/t1/t2都是类型变量。
3.2.2 复杂导出类型
多个type constructor的时候,困难在于声明的语法。看这个之前,
我觉得我们可以参考一下数学表达式的分析:
5+3 ---------(1)
3+3*6 -------(2)
b=3, a = 1 ? 3<<4+-3 : c = ~a++ | 2; --------- (3)
(3)显然不是那种一眼就能知道结果的表达式,虽然估计不会有人写出
那样风格的代码来,仔细观察一下可以发现,(3)的分析困难来源于:
*) 前缀、后缀、中缀、distfix运算符的混用
*) 一元、二元、三元运算符的混用
*) `-'号同时作为前缀操作符和中缀操作符
其中`distfix运算符'是指那些操作符散布在操作数当中的情况,c的
` ? : ' 就是典型的distfix运算符。
如果把类型声明也看成是表达式的话,复杂类型声明的分析困难
实际上和这个很类似。指针、引用的标志`*'、`&'相当于一元前缀
运算符,数组和函数的标志`['、`]'、`('、`)'相当于后缀运算符。
而`('、`)'既用来界定函数参数列表,又用来override优先级限制。
还好,倒是没有distfix的运算符。
和算术表达式类似,优先级在分析类型声明的时候也起到了很大
的作用。c语法规定,在类型声明表达式中,指针和引用的优先级
低,数组、函数以及表示override优先级的`('和`)'的优先级是同样
的。
所以:
int * f[5];
和
int *(f[5]);
等价,表示f是个数组,其元素是int指针,而若想表示指向int数组
的指针,则必须用括号来override这个优先级,也就是这么写:
int (*f)[5];
下面的cpp程序可以验证这一点:
// c.cpp, 用vc编译
#include <typeinfo>
#include <stdio.h>
int main()
{
int *f[5];
int *(g[5]);
int (*h)[5];
printf("%s/n", typeid(f).name());
printf("%s/n", typeid(g).name());
printf("%s/n", typeid(h).name());
return 0;
}
类似的:
int * f ();
和
int * (f());
等价,而和
int (*f)();
则不等价。
btw,把类型声明看成表达式的观点还可以和类型描述的概念很
好的结合起来:编译器求值这个表达式,得到一个类型描述,正
如人或者程序求值算术表达式得到一个数值结果一样。但是如上
所述,一个重要的区别是,类型声明表达式的分析需要类似解方
程的技巧。
继续说语法,形式语言的理论和实践已经形成很多有效的算法来
作这件事情,但对程序员来说,那些算法都有些枯燥,实际上更
多的还是靠直觉和试错。这里有个好消息是,c和cpp的语法都是
基本没有二义性的,也就是说除了极少的几个情况,只要我们能
分析出类型声明的一种语法结构,那么就可以放心的使用这个结
构来解释类型声明的含义,c标准委员会的专家们会保证不会有第
二种解释。就像下面的分析表现的那样,直觉、试错的缺点就是
不严格,但是多加练习、熟练之后就很有效了(试想一下,有哪
个小学毕业生不会凭直觉分析复杂的数学表达式?)
拿:
int (*Register (int (*pf)(const char *, const char *)))
(const char *, const char *);
作例子,首先把前面的`int'拿掉,因为显然这是一个type-specifier,
把后面的declarator部分记为:declarator-1,即:
declarator-1=(*Register (int (*pf)(const char *, const char *))) /
(const char *, const char *)
现在我们已经可以写出:
typeof(declarator-1)=INT ------------------------(1)
一旦我们分析出declarator-1的内部的结构,我们就可以按照前面的三个
公理来改写这个式子并最终得到整个类型声明的含义。ok,现在开始分
析declarator-1,很明显,declarator-1由两段括号括起来的部分组成,
先看末尾的一串括号括起来的东西:
(const char *, const char *)
我们意识到这里要出现一个function type constructor(不然还能是什么?),
令declarator-2表示剩下的部分,即:
declarator-2=(*Register (int (*pf)(const char *, const char *)))
结合1,由于:
declarator-1=declarator-2 (const char *, const char *)
所以现在我们可以写出:
typeof(declarator-2 (const char *, const char *))=INT
于是根据公理3,我们有:
typeof(declarator-2)=FUNCTION(INT; const char *, const char *); ----(2)
意思是declarator-2的类型是返回值为int,带两个类型为const char *
类型的参数的函数。其中`const char *'也许写成`POINTER((CONST(CHAR)))'
更合乎前面的习惯一些。
继续,declarator-2外头有一对括号,这个可不是表示函数类型构造,
而是保护Register前面的`*'的,按照c的语法的定义,分析到这个地步,
这样的括号是可以扔掉的。现在类型声明所要定义的标识符已经暴露
出来了,就是`Register',它前面是pointer,后面的一对括号表示函数
构造,即:`* A (B)'的形式,这里优先级就要起作用了,参看前面的例
子,因为函数构造的优先级高,所以函数声明部分先和Register结合,
再和`*'结合,令:
declarator-3=Register (int (*pf)(const char *, const char *))
这样:
declarator-2=( * declarator-3 )
根据(2),以及公理(1),有:
typeof(declarator-3)=POINTER(FUNCTION(int; const char *, const char *))
这样太罗嗦了,我们把等式右面的东西简写为PF,即:
PF=POINTER(FUNCTION(int; const char *, const char *))
typeof(declarator-3)=PF
再来分析declarator-3的结构,很简单,是个函数声明
typeof(Register (int (*pf)(const char *, const char *)))=PF
根据公理(3):
typeof(Register)=FUNCTION(PF; typeof(int (*pf)(const char *, const char *))));
而:typeof(int (*pf)(const char *, const char *)))这个类型表达式可以
按照和刚才完全一样的思路分析,巧了,刚好也等于已经分析过的PF:
typeof(int (*pf)(const char *, const char *)))=PF
这样,最后的结果就出来了:
typeof(Register)=FUNCTION(PF; PF)
4. 总结
和pascal的类型声明相比,c的类型声明的语法的确复杂了一些,甚至有点
让人疑心是完全没必要的复杂,尤其是考虑到可以通过引入typedef(类似
pascal的type equivalence语句)简化类型声明。不过为了阅读现有代码,
还是要适应这种情况的。
c的类型声明的难点在于类型构造的组合应用的情形,对这种情况,只要
成功的分析出其语法结构,就可以按照一种机械的方式翻译出所声明的
类型。语法分析的方法类似算术表达式的分析,需要考虑不同类型构造
的优先级。