C语言：陷阱和缺陷_2

2.1 理解声明

    我曾经和一些人聊过天，他们那时在书写在一个小型的微处理器上单机运行的C程序。当这台机器的开关打开的时候，硬件会调用地址为0处的子程序。

    为了模仿电源打开的情形，我们要设计一条C语句来显式地调用这个子程序。经过一些思考，我们写出了下面的语句：

(*(void(*)())0)();

    这样的表达式会令C程序员心惊胆战。但是，并不需要这样，因为他们可以在一个简单的规则的帮助下很容易地构造它：以你使用的方式声明它。

    每个C变量声明都具有两个部分：一个类型和一组具有特定格式的期望用来对该类型求值的表达式。最简单的表达式就是一个变量：

float f, g;

说明表达式f和g——在求值的时候——具有类型float。由于待求值的时表达式，因此可以自由地使用圆括号：

float ((f));

这表示((f))求值为float并且因此，通过推断，f也是一个float。

    同样的逻辑用在函数和指针类型。例如：

float ff();

表示表达式ff()是一个float，因此ff是一个返回一个float的函数。类似地，

float *pf;

表示*pf是一个float并且因此pf是一个指向一个float的指针。

    这些形式的组合声明对表达式是一样的。因此，

float *g(), (*h)();

表示*g()和(*h)()都是float表达式。由于()比*绑定得更紧密，*g()和*(g())表示同样的东西：g是一个返回指float指针的函数，而h是一个指向返回float的函数的指针。

    当我们知道如何声明一个给定类型的变量以后，就能够很容易地写出一个类型的模型（cast）：只要删除变量名和分号并将所有的东西包围在一对圆括号中即可。因此，由于

float *g();

声明g是一个返回float指针的函数，所以(float *())就是它的模型。

    有了这些知识的武装，我们现在可以准备解决(*(void(*)())0)()了。 我们可以将它分为两个部分进行分析。首先，假设我们有一个变量fp，它包含了一个函数指针，并且我们希望调用fp所指向的函数。可以这样写：

(*fp)();

如果fp是一个指向函数的指针，则*fp就是函数本身，因此(*fp)()是调用它的一种方法。(*fp)中的括号是必须的，否则这个表达式将会被分析为*(fp())。我们现在要找一个适当的表达式来替换fp。

    这个问题就是我们的第二步分析。如果C可以读入并理解类型，我们可以写：

(*0)();

但这样并不行，因为*运算符要求必须有一个指针作为他的操作数。另外，这个操作数必须是一个指向函数的指针，以保证*的结果可以被调用。因此，我们需要将0转换为一个可以描述“指向一个返回void的函数的指针”的类型。

    如果fp是一个指向返回void的函数的指针，则(*fp)()是一个void值，并且它的声明将会是这样的：

void (*fp)();

因此，我们需要写：

void (*fp)();
(*fp)();

来声明一个哑变量。一旦我们知道了如何声明该变量，我们也就知道了如何将一个常数转换为该类型：只要从变量的声明中去掉名字即可。因此，我们像下面这样将0转换为一个“指向返回void的函数的指针”：

(void(*)())0

接下来，我们用(void(*)())0来替换fp：

(*(void(*)())0)();

结尾处的分号用于将这个表达式转换为一个语句。

    在这里，我们就解决了这个问题时没有使用typedef声明。通过使用它，我们可以更清晰地解决这个问题：

typedef void (*funcptr)();
(*(funcptr)0)();

2.2 运算符并不总是具有你所想象的优先级

    假设有一个声明了的常量FLAG是一个整数，其二进制表示中的某一位被置位（换句话说，它是2的某次幂），并且你希望测试一个整型变量flags该位是否被置位。通常的写法是：

if(flags & FLAG) ...

其意义对于很多C程序员都是很明确的：if语句测试括号中的表达式求值的结果是否为0。出于清晰的目的我们可以将它写得更明确：

if(flags & FLAG != 0) ...

这个语句现在更容易理解了。但它仍然是错的，因为!=比&绑定得更紧密，因此它被分析为：

if(flags & (FLAG != 0)) ...

这（偶尔）是可以的，如FLAG是1或0（！）的时候，但对于其他2的幂是不行的^脚注[2]。

    假设你有两个整型变量，h和l，它们的值在0和15（含0和15）之间，并且你希望将r设置为8位值，其低位为l，高位为h。一种自然的写法是：

r = h << 4 + 1;

不幸的是，这是错误的。加法比移位绑定得更紧密，因此这个例子等价于：

r = h << (4 + l);

正确的方法有两种：

r = (h << 4) + l;

r = h << 4 | l;

    避免这种问题的一个方法是将所有的东西都用括号括起来，但表达式中的括号过度就会难以理解，因此最好还是是记住C中的优先级。

    不幸的是，这有15个，太困难了。然而，通过将它们分组可以变得容易。

    绑定得最紧密的运算符并不是真正的运算符：下标、函数调用和结构选择。这些都与左边相关联。

    接下来是一元运算符。它们具有真正的运算符中的最高优先级。由于函数调用比一元运算符绑定得更紧密，你必须写(*p)()来调用p指向的函数；*p()表示p是一个返回一个指针的函数。转换是一元运算符，并且和其他一元运算符具有相同的优先级。一元运算符是右结合的，因此*p++表示*(p++)，而不是(*p)++。

    在接下来是真正的二元运算符。其中数学运算符具有最高的优先级，然后是移位运算符、关系运算符、逻辑运算符、赋值运算符，最后是条件运算符。需要记住的两个重要的东西是：

所有的逻辑运算符具有比所有关系运算符都低的优先级。
一位运算符比关系运算符绑定得更紧密，但又不如数学运算符。
    在这些运算符类别中，有一些奇怪的地方。乘法、除法和求余具有相同的优先级，加法和减法具有相同的优先级，以及移位运算符具有相同的优先级。

    还有就是六个关系运算符并不具有相同的优先级：==和!=的优先级比其他关系运算符要低。这就允许我们判断a和b是否具有与c和d相同的顺序，例如：

a < b == c < d

    在逻辑运算符中，没有任何两个具有相同的优先级。按位运算符比所有顺序运算符绑定得都紧密，每种与运算符都比相应的或运算符绑定得更紧密，并且按位异或（^）运算符介于按位与和按位或之间。

    三元运算符的优先级比我们提到过的所有运算符的优先级都低。这可以保证选择表达式中包含的关系运算符的逻辑组合特性，如：

z = a < b && b < c ? d : e

    这个例子还说明了赋值运算符具有比条件运算符更低的优先级是有意义的。另外，所有的复合赋值运算符具有相同的优先级并且是自右至左结合的，因此

a = b = c

和

b = c; a = b;

是等价的。

    具有最低优先级的是逗号运算符。这很容易理解，因为逗号通常在需要表达式而不是语句的时候用来替代分号。

    赋值是另一种运算符，通常具有混合的优先级。例如，考虑下面这个用于复制文件的循环：

while(c = getc(in) != EOF)
    putc(c, out);

这个while循环中的表达式看起来像是c被赋以getc(in)的值，接下来判断是否等于EOF以结束循环。不幸的是，赋值的优先级比任何比较操作都低，因此c的值将会是getc(in)和EOF比较的结果，并且会被抛弃。因此，“复制”得到的文件将是一个由值为1的字节流组成的文件。

    上面这个例子正确的写法并不难：

while((c = getc(in)) != EOF)
    putc(c, out);

然而，这种错误在很多复杂的表达式中却很难被发现。例如，随UNIX系统一同发布的lint程序通常带有下面的错误行：

if (((t = BTYPE(pt1->aty) == STRTY) || t == UNIONTY) {

这条语句希望给t赋一个值，然后看t是否与STRTY或UNIONTY相等。而实际的效果却大不相同^脚注[3]。

    C中的逻辑运算符的优先级具有历史原因。B——C的前辈——具有和C中的&和|运算符对应的逻辑运算符。尽管它们的定义是按位的 ，但编译器在条件判断上下文中将它们视为和&&和||一样。当在C中将它们分开后，优先级的改变是很危险的^脚注[4]。

2.3 看看这些分号！

    C中的一个多余的分号通常会带来一点点不同：或者是一个空语句，无任何效果；或者编译器可能提出一个诊断消息，可以方便除去掉它。一个重要的区别是在必须跟有一个语句的if和while语句中。考虑下面的例子：

if(x[i] > big);
    big = x[i];

这不会发生编译错误，但这段程序的意义与：

if(x[i] > big)
    big = x[i];

就大不相同了。第一个程序段等价于：

if(x[i] > big) { }
big = x[i];

也就是等价于：

big = x[i];

（除非x、i或big是带有副作用的宏）。

    另一个因分号引起巨大不同的地方是函数定义前面的结构声明的末尾[译注：这句话不太好听，看例子就明白了]。考虑下面的程序片段：

struct foo {
    int x;
}

f() {
    ...
}

在紧挨着f的第一个}后面丢失了一个分号。它的效果是声明了一个函数f，返回值类型是struct foo，这个结构成了函数声明的一部分。如果这里出现了分号，则f将被定义为具有默认的整型返回值^脚注[5]。

2.4 switch语句

    通常C中的switch语句中的case段可以进入下一个。例如，考虑下面的C和Pascal程序片断：

switch(color) {
case 1: printf ("red");
        break;
case 2: printf ("yellow");
        break;
case 3: printf ("blue");
        break;
}

case color of
1: write ('red');
2: write ('yellow');
3: write ('blue');
end

    这两个程序片断都作相同的事情：根据变量color的值是1、2还是3打印red、yellow或blue（没有新行符）。这两个程序片断非常相似，只有一点不同：Pascal程序中没有C中相应的break语句。C中的case标签是真正的标签：控制流程可以无限制地进入到一个case标签中。

    看看另一种形式，假设C程序段看起来更像Pascal：

switch(color) {
case 1: printf ("red");
case 2: printf ("yellow");
case 3: printf ("blue");
}

并且假设color的值是2。则该程序将打印yellowblue，因为控制自然地转入到下一个printf()的调用。

    这既是C语言switch语句的优点又是它的弱点。说它是弱点，是因为很容易忘记一个break语句，从而导致程序出现隐晦的异常行为。说它是优点，是因为通过故意去掉break语句，可以很容易实现其他方法难以实现的控制结构。尤其是在一个大型的switch语句中，我们经常发现对一个case的处理可以简化其他一些特殊的处理。

    例如，设想有一个程序是一台假想的机器的翻译器。这样的一个程序可能包含一个switch语句来处理各种操作码。在这样一台机器上，通常减法在对其第二个运算数进行变号后就变成和加法一样了。因此，最好可以写出这样的语句：

case SUBTRACT:
    opnd2 = -opnd2;
    /* no break; */
case ADD:
    ...

    另外一个例子，考虑编译器通过跳过空白字符来查找一个记号。这里，我们将空格、制表符和新行符视为是相同的，除了新行符还要引起行计数器的增长外：

case '\n':
    linecount++;
    /* no break */
case '\t':
case ' ':
    ...

2.5 函数调用

    和其他程序设计语言不同，C要求一个函数调用必须有一个参数列表，但可以没有参数。因此，如果f是一个函数，

f();

就是对该函数进行调用的语句，而

f;

什么也不做。它会作为函数地址被求值，但不会调用它^脚注[6]。

2.6 悬挂else问题

    在讨论任何语法缺陷时我们都不会忘记提到这个问题。尽管这一问题不是C语言所独有的，但它仍然伤害着那些有着多年经验的C程序员。

    考虑下面的程序片断：

if(x == 0)
    if(y == 0) error();
else {
    z = x + y;
    f(&z);
}

    写这段程序的程序员的目的明显是将情况分为两种：x = 0和x != 0。在第一种情况中，程序段什么都不做，除非y = 0时调用error()。第二种情况中，程序设置z = x + y并以z的地址作为参数调用f()。

    然而， 这段程序的实际效果却大为不同。其原因是一个else总是与其最近的if相关联。如果我们希望这段程序能够按照实际的情况运行，应该这样写：

if(x == 0) {
    if(y == 0)
        error();
    else {
        z = x + y;
        f(&z);
    }
}

换句话说，当x != 0发生时什么也不做。如果要达到第一个例子的效果，应该写：

if(x == 0) {
    if(y ==0)
        error();
}
else {
    z = z + y;
    f(&z);
}

脚注
    1. 本文是基于图书《C Traps and Pitfalls》（Addison-Wesley, 1989, ISBN 0-201-17928-8）的一个扩充，有兴趣的读者可以读一读它。
    2. 因为!=的结果不是1就是0。
    3. 感谢Guy Harris为我指出这个问题。
    4. Dennis Ritchie和Steve Johnson同时向我指出了这个问题。
    5. 感谢一位不知名的志愿者提出这个问题。
    6. 感谢Richard Stevens指出了这个问题。
    7. 一些C编译器要求每个外部对象仅有一个定义，但可以有多个声明。使用这样的编译器时，我们何以很容易地将一个声明放到一个包含文件中，并将其定义放到其它地方。这意味着每个外部对象的类型将出现两次，但这比出现多于两次要好。
    8. 分离函数参数用的逗号不是逗号运算符。例如在f(x, y)中，x和y的获取顺序是未定义的，但在g((x, y))中不是这样的。其中g只有一个参数。它的值是通过对x进行求值、抛弃这个值、再对y进行求值来确定的。
    9. 预处理器还可以很容易地组织这样的显式常量以能够方便地找到它们。
    10. PDP-11和VAX-11是数组设备集团（DEC）的商标。