c语言-陷阱和缺陷.doc

《c语言-陷阱和缺陷.doc》由会员分享，可在线阅读，更多相关《c语言-陷阱和缺陷.doc（38页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。

1、C语言像一把雕刻刀，锋利，并且在技师手中非常有用。和任何锋利的工具一样，C会伤到那些不能掌握它的人。本文介绍C语言伤害粗心的人的方法，以及如何避免伤害。脚注1 0 简介 C语言及其典型实现被设计为能被专家们容易地使用。这门语言简洁并附有表达力。但有一些限制可以保护那些浮躁的人。一个浮躁的人可以从这些条款中获得一些帮助。 在本文中，我们将会看一看这些未可知的益处。这是由于它的未可知，我们无法为其进行完全的分类。不过，我们仍然通过研究为了一个C程序的运行所需要做的事来做到这些。我们假设读者对C语言至少有个粗浅的了解。 第一部分研究了当程序被划分为记号时会发生的问题。第二部分继续研究了当程序的记号被

2、编译器组合为声明、表达式和语句时会出现的问题。第三部分研究了由多个部分组成、分别编译并绑定到一起的C程序。第四部分处理了概念上的误解：当一个程序具体执行时会发生的事情。第五部分研究了我们的程序和它们所使用的常用库之间的关系。在第六部分中，我们注意到了我们所写的程序也不并不是我们所运行的程序；预处理器将首先运行。最后，第七部分讨论了可移植性问题：一个能在一个实现中运行的程序无法在另一个实现中运行的原因。 1 词法缺陷 编译器的第一个部分常被称为词法分析器（lexical analyzer）。词法分析器检查组成程序的字符序列，并将它们划分为记号（token）一个记号是一个有一个或多个字符的序列，它

3、在语言被编译时具有一个（相关地）统一的意义。在C中， 例如，记号-的意义和组成它的每个独立的字符具有明显的区别，而且其意义独立于-出现的上下文环境。 另外一个例子，考虑下面的语句： if(x big) big = x; 该语句中的每一个分离的字符都被划分为一个记号，除了关键字if和标识符big的两个实例。 事实上，C程序被两次划分为记号。首先是预处理器读取程序。它必须对程序进行记号划分以发现标识宏的标识符。它必须通过对每个宏进行求值来替换宏调用。最后，经过宏替换的程序又被汇集成字符流送给编译器。编译器再第二次将这个流划分为记号。 在这一节中，我们将探索对记号的意义的普遍的误解以及记号和组成它们

4、的字符之间的关系。稍后我们将谈到预处理器。 1.1 = 不是 = 从Algol派生出来的语言，如Pascal和Ada，用:=表示赋值而用=表示比较。而C语言则是用=表示赋值而用=表示比较。这是因为赋值的频率要高于比较，因此为其分配更短的符号。 此外，C还将赋值视为一个运算符，因此可以很容易地写出多重赋值（如a = b = c），并且可以将赋值嵌入到一个大的表达式中。 这种便捷导致了一个潜在的问题：可能将需要比较的地方写成赋值。因此，下面的语句好像看起来是要检查x是否等于y： if(x = y) foo(); 而实际上是将x设置为y的值并检查结果是否非零。在考虑下面的一个希望跳过空格、制表符和换

5、行符的循环： while(c = | c = t | c = n) c = getc(f); 在与t进行比较的地方程序员错误地使用=代替了=。这个“比较”实际上是将t赋给c，然后判断c的（新的）值是否为零。因为t不为零，这个“比较”将一直为真，因此这个循环会吃尽整个文件。这之后会发生什么取决于特定的实现是否允许一个程序读取超过文件尾部的部分。如果允许，这个循环会一直运行。 一些C编译器会对形如e1 = e2的条件给出一个警告以提醒用户。当你趋势需要先对一个变量进行赋值之后再检查变量是否非零时，为了在这种编译器中避免警告信息，应考虑显式给出比较符。换句话说，将： if(x = y) foo();

6、 改写为： if(x = y) != 0) foo(); 这样可以清晰地表示你的意图。 1.2 & 和 | 不是 & 和 | 容易将=错写为=是因为很多其他语言使用=表示比较运算。 其他容易写错的运算符还有&和&，或|和|，这主要是因为C语言中的&和|运算符于其他语言中具有类似功能的运算符大为不同。我们将在第4节中贴近地观察这些运算符。 1.3 多字符记号 一些C记号，如/、*和=只有一个字符。而其他一些C记号，如/*和=，以及标识符，具有多个字符。当C编译器遇到紧连在一起的/和*时，它必须能够决定是将这两个字符识别为两个分离的记号还是一个单独的记号。C语言参考手册说明了如何决定：“如果输入流

7、到一个给定的字符串为止已经被识别为记号，则应该包含下一个字符以组成能够构成记号的最长的字符串”。因此，如果/是一个记号的第一个字符，并且/后面紧随了一个*，则这两个字符构成了注释的开始，不管其他上下文环境。 下面的语句看起来像是将y的值设置为x的值除以p所指向的值： y = x/*p/* p 指向除数 */; 实际上，/*开始了一个注释，因此编译器简单地吞噬程序文本，直到*/的出现。换句话说，这条语句仅仅把y的值设置为x的值，而根本没有看到p。将这条语句重写为： y = x / *p/* p 指向除数 */; 或者干脆是 y = x / (*p)/* p指向除数 */; 它就可以做注释所暗示的

8、除法了。 这种模棱两可的写法在其他环境中就会引起麻烦。例如，老版本的C使用=+表示现在版本中的+=。这样的编译器会将 a=-1; 视为 a =- 1; 或 a = a - 1; 这会让打算写 a = -1; 的程序员感到吃惊。 另一方面，这种老版本的C编译器会将 a=/*b; 断句为 a =/ *b; 尽管/*看起来像一个注释。 1.4 例外 组合赋值运算符如+=实际上是两个记号。因此， a + /* strange */ = 1 和 a += 1 是一个意思。看起来像一个单独的记号而实际上是多个记号的只有这一个特例。特别地， p - a 是不合法的。它和 p - a 不是同义词。 另一方面，

9、有些老式编译器还是将=+视为一个单独的记号并且和+=是同义词。 1.5 字符串和字符 单引号和双引号在C中的意义完全不同，在一些混乱的上下文中它们会导致奇怪的结果而不是错误消息。 包围在单引号中的一个字符只是书写整数的另一种方法。这个整数是给定的字符在实现的对照序列中的一个对应的值。因此，在一个ASCII实现中，a和0141或97表示完全相同的东西。而一个包围在双引号中的字符串，只是书写一个有双引号之间的字符和一个附加的二进制值为零的字符所初始化的一个无名数组的指针的一种简短方法。 线面的两个程序片断是等价的： printf(Hello worldn); char hello = H, e,

10、l, l, o, , w, o, r, l, d, n, 0 ; printf(hello); 使用一个指针来代替一个整数通常会得到一个警告消息（反之亦然），使用双引号来代替单引号也会得到一个警告消息（反之亦然）。但对于不检查参数类型的编译器却除外。因此，用 printf(n); 来代替 printf(n); 通常会在运行时得到奇怪的结果。 由于一个整数通常足够大，以至于能够放下多个字符，一些C编译器允许在一个字符常量中存放多个字符。这意味着用yes代替yes将不会被发现。后者意味着“分别包含y、e、s和一个空字符的四个连续存贮器区域中的第一个的地址”，而前者意味着“在一些实现定义的样式中表示

11、由字符y、e、s联合构成的一个整数”。这两者之间的任何一致性都纯属巧合。 2 句法缺陷 要理解C语言程序，仅了解构成它的记号是不够的。还要理解这些记号是如何构成声明、表达式、语句和程序的。尽管这些构成通常都是定义良好的，但这些定义有时候是有悖于直觉的或混乱的。 在这一节中，我们将着眼于一些不明显句法构造。 2.1 理解声明 我曾经和一些人聊过天，他们那时在书写在一个小型的微处理器上单机运行的C程序。当这台机器的开关打开的时候，硬件会调用地址为0处的子程序（以下便是相关的）。 为了模仿电源打开的情形，我们要设计一条C语句来显式地调用这个子程序。经过一些思考，我们写出了下面的语句： (*(void

12、(*)()0)(); 这样的表达式会令C程序员心惊胆战。但是，并不需要这样，因为他们可以在一个简单的规则的帮助下很容易地构造它：以你使用的方式声明它。 每个C变量声明都具有两个部分：一个类型和一组具有特定格式的期望用来对该类型求值的表达式。最简单的表达式就是一个变量： float f, g; 说明表达式f和g-在求值的时候-具有类型float。由于待求值的时表达式，因此可以自由地使用圆括号： float (f); 这表示(f)求值为float并且因此，通过推断，f也是一个float。 同样的逻辑用在函数和指针类型。例如： float ff(); 表示表达式ff()是一个float，因此ff是一

13、个返回一个float的函数。类似地， float *pf; 表示*pf是一个float并且因此pf是一个指向一个float的指针。 这些形式的组合声明对表达式是一样的。因此， float *g(), (*h)(); 表示*g()和(*h)()都是float表达式。由于()比*绑定得更紧密，*g()和*(g()表示同样的东西：g是一个返回float指针的函数，而h是一个指向返回float的函数的指针。 当我们知道如何声明一个给定类型的变量以后，就能够很容易地写出一个类型的模型（cast）：只要删除变量名和分号并将所有的东西包围在一对圆括号中即可。因此，由于 float *g(); 声明g是一个返

14、回float指针的函数，所以(float *()就是它的模型。 有了这些知识的武装，我们现在可以准备解决(*(void(*)()0)()了。 我们可以将它分为两个部分进行分析。首先，假设我们有一个变量fp，它包含了一个函数指针，并且我们希望调用fp所指向的函数。可以这样写： (*fp)(); 如果fp是一个指向函数的指针，则*fp就是函数本身，因此(*fp)()是调用它的一种方法。(*fp)中的括号是必须的，否则这个表达式将会被分析为*(fp()。我们现在要找一个适当的表达式来替换fp。 这个问题就是我们的第二步分析。如果C可以读入并理解类型，我们可以写： (*0)(); 但这样并不行，因为*

15、运算符要求必须有一个指针作为他的操作数。另外，这个操作数必须是一个指向函数的指针，以保证*的结果可以被调用。因此，我们需要将0转换为一个可以描述“指向一个返回void的函数的指针”的类型。 如果fp是一个指向返回void的函数的指针，则(*fp)()是一个void值，并且它的声明将会是这样的： void (*fp)(); 因此，我们需要写： void (*fp)(); (*fp)(); 来声明一个哑变量。一旦我们知道了如何声明该变量，我们也就知道了如何将一个常数转换为该类型：只要从变量的声明中去掉名字即可。因此，我们像下面这样将0转换为一个“指向返回void的函数的指针”： (void(*)(

16、)0 接下来，我们用(void(*)()0来替换fp： (*(void(*)()0)(); 结尾处的分号用于将这个表达式转换为一个语句。 在这里，我们就解决了这个问题时没有使用typedef声明。通过使用它，我们可以更清晰地解决这个问题： typedef void (*funcptr)(); (*(funcptr)0)(); 2.2 运算符并不总是具有你所想象的优先级 假设有一个声明了的常量FLAG是一个整数，其二进制表示中的某一位被置位（换句话说，它是2的某次幂），并且你希望测试一个整型变量flags该位是否被置位。通常的写法是： if(flags & FLAG) . 其意义对于很多C程序员

17、都是很明确的：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; 不幸的是，这是错误的。加法比移位绑定得更紧密，因此这个例子等价于：

18、 r = h (4 + l); 正确的方法有两种： r = (h 4) + l; r = h 4 | l; 避免这种问题的一个方法是将所有的东西都用括号括起来，但表达式中的括号过度就会难以理解，因此最好还是是记住C中的优先级。 不幸的是，这有15个，太困难了。然而，通过将它们分组可以变得容易。 绑定得最紧密的运算符并不是真正的运算符：下标、函数调用和结构选择。这些都与左边相关联。 接下来是一元运算符。它们具有真正的运算符中的最高优先级。由于函数调用比一元运算符绑定得更紧密，你必须写(*p)()来调用p指向的函数；*p()表示p是一个返回一个指针的函数。转换是一元运算符，并且和其他一元运算符具有

19、相同的优先级。一元运算符是右结合的，因此*p+表示*(p+)，而不是(*p)+。 在接下来是真正的二元运算符。其中数学运算符具有最高的优先级，然后是移位运算符、关系运算符、逻辑运算符、赋值运算符，最后是条件运算符。需要记住的两个重要的东西是： 所有的逻辑运算符具有比所有关系运算符都低的优先级。 一位运算符比关系运算符绑定得更紧密，但又不如数学运算符。 在这些运算符类别中，有一些奇怪的地方。乘法、除法和求余具有相同的优先级，加法和减法具有相同的优先级，以及移位运算符具有相同的优先级。 还有就是六个关系运算符并不具有相同的优先级：=和!=的优先级比其他关系运算符要低。这就允许我们判断a和b是否具有

20、与c和d相同的顺序，例如： a b = c d 在逻辑运算符中，没有任何两个具有相同的优先级。按位运算符比所有顺序运算符绑定得都紧密，每种与运算符都比相应的或运算符绑定得更紧密，并且按位异或（）运算符介于按位与和按位或之间。 三元运算符的优先级比我们提到过的所有运算符的优先级都低。这可以保证选择表达式中包含的关系运算符的逻辑组合特性，如： z = a b & b aty) = STRTY) | t = UNIONTY) 这条语句希望给t赋一个值，然后看t是否与STRTY或UNIONTY相等。而实际的效果却大不相同脚注3。 C中的逻辑运算符的优先级具有历史原因。B-C的前辈-具有和C中的&和|运

21、算符对应的逻辑运算符。尽管它们的定义是按位的 ，但编译器在条件判断上下文中将它们视为和&和|一样。当在C中将它们分开后，优先级的改变是很危险的脚注4。 2.3 看看这些分号！ C中的一个多余的分号通常会带来一点点不同：或者是一个空语句，无任何效果；或者编译器可能提出一个诊断消息，可以方便除去掉它。一个重要的区别是在必须跟有一个语句的if和while语句中。考虑下面的例子： if(xi big); big = xi; 这不会发生编译错误，但这段程序的意义与： if(xi big) big = xi; 就大不相同了。第一个程序段等价于： if(xi big) big = xi; 也就是等价于： b

22、ig = xi; （除非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: prin

23、tf (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标签中。 看看另一种形式，假设

24、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的

25、处理可以简化其他一些特殊的处理。 例如，设想有一个程序是一台假想的机器的翻译器。这样的一个程序可能包含一个switch语句来处理各种操作码。在这样一台机器上，通常减法在对其第二个运算数进行变号后就变成和加法一样了。因此，最好可以写出这样的语句： case SUBTRACT: opnd2 = -opnd2; /* no break; */ case ADD: . 另外一个例子，考虑编译器通过跳过空白字符来查找一个记号。这里，我们将空格、制表符和新行符视为是相同的，除了新行符还要引起行计数器的增长外： case n: linecount+; /* no break */ case t: case

26、: . 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。在第一种情况中，

27、程序段什么都不做，除非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); 3 链接 一个C程序可能有很多部分组成，它们

28、被分别编译，并由一个通常称为链接器、链接编辑器或加载器的程序绑定到一起。由于编译器一次通常只能看到一个文件，因此它无法检测到需要程序的多个源文件的内容才能发现的错误。 在这一节中，我们将看到一些这种类型的错误。有一些C实现，但不是所有的，带有一个称为lint的程序来捕获这些错误。如果具有一个这样的程序，那么无论怎样地强调它的重要性都不过分。 3.1 你必须自己检查外部类型 假设你有一个C程序，被划分为两个文件。其中一个包含如下声明： int n; 而令一个包含如下声明： long n; 这不是一个有效的C程序，因为一些外部名称在两个文件中被声明为不同的类型。然而，很多实现检测不到这个错误，因为

29、编译器在编译其中一个文件时并不知道另一个文件的内容。因此，检查类型的工作只能由链接器（或一些工具程序如lint）来完成；如果操作系统的链接器不能识别数据类型，C编译器也没法过多地强制它。 那么，这个程序运行时实际会发生什么？这有很多可能性： 实现足够聪明，能够检测到类型冲突。则我们会得到一个诊断消息，说明n在两个文件中具有不同的类型。 你所使用的实现将int和long视为相同的类型。典型的情况是机器可以自然地进行32位运算。在这种情况下你的程序或许能够工作，好象你两次都将变量声明为long（或int）。但这种程序的工作纯属偶然。 n的两个实例需要不同的存储，它们以某种方式共享存储区，即对其中一

30、个的赋值对另一个也有效。这可能发生，例如，编译器可以将int安排在long的低位。不论这是基于系统的还是基于机器的，这种程序的运行同样是偶然。 n的两个实例以另一种方式共享存储区，即对其中一个赋值的效果是对另一个赋以不同的值。在这种情况下，程序可能失败。 这种情况发生的里一个例子出奇地频繁。程序的某一个文件包含下面的声明： char filename = etc/passwd; 而另一个文件包含这样的声明： char *filename; 尽管在某些环境中数组和指针的行为非常相似，但它们是不同的。在第一个声明中，filename是一个字符数组的名字。尽管使用数组的名字可以产生数组第一个元素的指

31、针，但这个指针只有在需要的时候才产生并且不会持续。在第二个声明中，filename是一个指针的名字。这个指针可以指向程序员让它指向的任何地方。如果程序员没有给它赋一个值，它将具有一个默认的0值（null）译注：实际上，在C中一个为初始化的指针通常具有一个随机的值，这是很危险的！。 这两个声明以不同的方式使用存储区，他们不可能共存。 避免这种类型冲突的一个方法是使用像lint这样的工具（如果可以的话）。为了在一个程序的不同编译单元之间检查类型冲突，一些程序需要一次看到其所有部分。典型的编译器无法完成，但lint可以。 避免该问题的另一种方法是将外部声明放到包含文件中。这时，一个外部对象的类型仅出

32、现一次脚注7。 4 语义缺陷 一个句子可以是精确拼写的并且没有语法错误，但仍然没有意义。在这一节中，我们将会看到一些程序的写法会使得它们看起来是一个意思，但实际上是另一种完全不同的意思。 我们还要讨论一些表面上看起来合理但实际上会产生未定义结果的环境。我们这里讨论的东西并不保证能够在所有的C实现中工作。我们暂且忘记这些能够在一些实现中工作但可能不能在另一些实现中工作的东西，直到第7节讨论可以执行问题为止。 4.1 表达式求值顺序 一些C运算符以一种已知的、特定的顺序对其操作数进行求值。但另一些不能。例如，考虑下面的表达式： a b & c d C语言定义规定a b首先被求值。如果a确实小于b，

33、c d必须紧接着被求值以计算整个表达式的值。但如果a大于或等于b，则c d根本不会被求值。 要对a b求值，编译器对a和b的求值就会有一个先后。但在一些机器上，它们也许是并行进行的。 C中只有四个运算符&、|、?:和,指定了求值顺序。&和|最先对左边的操作数进行求值，而右边的操作数只有在需要的时候才进行求值。而?:运算符中的三个操作数：a、b和c，最先对a进行求值，之后仅对b或c中的一个进行求值，这取决于a的值。,运算符首先对左边的操作数进行求值，然后抛弃它的值，对右边的操作数进行求值脚注8。 C中所有其它的运算符对操作数的求值顺序都是未定义的。事实上，赋值运算符不对求值顺序做出任何保证。 出

34、于这个原因，下面这种将数组x中的前n个元素复制到数组y中的方法是不可行的： i = 0; while(i n) yi = xi+; 其中的问题是yi的地址并不保证在i增长之前被求值。在某些实现中，这是可能的；但在另一些实现中却不可能。另一种情况出于同样的原因会失败： i = 0; while(i n) yi+ = xi; 而下面的代码是可以工作的： i = 0; while(i n) yi = xi; i+; 当然，这可以简写为： for(i = 0; i n; i+) yi = xi; 4.2 &、|和!运算符 C中有两种逻辑运算符，在某些情况下是可以交换的：按位运算符&、|和，以及逻辑运算

35、符&、|和!。一个程序员如果用某一类运算符替换相应的另一类运算符会得到某些奇怪的效果：程序可能会正确地工作，但这纯属偶然。 &、|和!运算符将它们的参数视为仅有“真”或“假”，通常约定0代表“假”而其它的任意值都代表“真”。这些运算符返回1表示“真”而返回0表示“假”，而且&和|运算符当可以通过左边的操作数确定其返回值时，就不会对右边的操作数进行求值。 因此!10是零，因为10非零；10 & 12是1，因为10和12都非零；10 | 12也是1，因为10非零。另外，最后一个表达式中的12不会被求值，10 | f()中的f()也不会被求值。 考虑下面这段用于在一个表中查找一个特定元素的程序： i

36、 = 0; while(i tabsize & tabi != x) i+; 这段循环背后的意思是如果i等于tabsize时循环结束，元素未被找到。否则，i包含了元素的索引。 假设这个例子中的&不小心被替换为了&，这个循环可能仍然能够工作，但只有两种幸运的情况可以使它停下来。 首先，这两个操作都是当条件为假时返回0，当条件为真时返回1。只要x和y都是1或0，x & y和x & y都具有相同的值。然而，如果当使用了出了1之外的非零值表示“真”时互换了这两个运算符，这个循环将不会工作。 其次，由于数组元素不会改变，因此越过数组最后一个元素进一个位置时是无害的，循环会幸运地停下来。失误的程序会越过数

37、组的结尾，因为&不像&，总是会对所有的操作数进行求值。因此循环的最后一次获取tabi时i的值已经等于tabsize了。如果tabsize是tab中元素的数量， 则会取到tab中不存在的一个值。 4.3 下标从零开始 在很多语言中，具有n个元素的数组其元素的号码和它的下标是从1到n严格对应的。但在C中不是这样。 一个具有n个元素的C数组中没有下标为n的元素，其中的元素的下标是从0到n - 1。因此从其它语言转到C语言的程序员应该特别小心地使用数组： int i, a10; for(i = 1; i = 10; i+) ai = 0; 这个例子的目的是要将a中的每个元素都设置为0，但没有期望的效果

38、。因为for语句中的比较i 10被替换成了i = 10，a中的一个编号为10的并不存在的元素被设置为了0，这样内存中a后面的一个字被破坏了。如果编译该程序的编译器按照降序地址为用户变量分配内存，则a后面就是i。将i设置为零会导致该循环陷入一个无限循环。 4.4 C并不总是转换实参 下面的程序段由于两个原因会失败： double s; s = sqrt(2); printf(%gn, s); 第一个原因是sqrt()需要一个double值作为它的参数，但没有得到。第二个原因是它返回一个double值但没有这样声名。改正的方法只有一个： double s, sqrt(); s = sqrt(2.0

39、); printf(%gn, s); C中有两个简单的规则控制着函数参数的转换：(1)比int短的整型被转换为int；(2)比double短的浮点类型被转换为double。所有的其它值不被转换。确保函数参数类型的正确行使程序员的责任。 因此，一个程序员如果想使用如sqrt()这样接受一个double类型参数的函数，就必须仅传递给它float或double类型的参数。常数2是一个int，因此其类型是错误的。 当一个函数的值被用在表达式中时，其值会被自动地转换为适当的类型。然而，为了完成这个自动转换，编译器必须知道该函数实际返回的类型。没有更进一步声名的函数被假设返回int，因此声名这样的函数并不

40、是必须的。然而，sqrt()返回double，因此在成功使用它之前必须要声名。 实际上，C实现通常允许一个文件包含include语句来包含如sqrt()这些库函数的声名，但是对那些自己写函数的程序员来说，书写声名也是必要的-或者说，对那些书写非凡的C程序的人来说是有必要的。 这里有一个更加壮观的例子： main() int i; char c; for(i = 0; i 5; i+) scanf(%d, &c); printf(%d, i); printf(n); 表面上看，这个程序从标准输入中读取五个整数并向标准输出写入0 1 2 3 4。实际上，它并不总是这么做。譬如在一些编译器中，它的输

41、出为0 0 0 0 0 1 2 3 4。 为什么？因为c的声名是char而不是int。当你令scanf()去读取一个整数时，它需要一个指向一个整数的指针。但这里它得到的是一个字符的指针。但scanf()并不知道它没有得到它所需要的：它将输入看作是一个指向整数的指针并将一个整数存贮到那里。由于整数占用比字符更多的内存，这样做会影响到c附近的内存。 c附近确切是什么是编译器的事；在这种情况下这有可能是i的低位。因此，每当向c中读入一个值，i就被置零。当程序最后到达文件结尾时，scanf()不再尝试向c中放入新值，i才可以正常地增长，直到循环结束。 4.5 指针不是数组 C程序通常将一个字符串转换为一个以空字符结尾的字符数组。假设我们有两个这样的字符串s和t，并且我们想要将它们连接为一个