`
逆风的香1314
  • 浏览: 1436758 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

C语言缺陷与陷阱(笔记)

阅读更多

[修订说明]

    改正了文中的大部分错别字和格式错误,并对一些句子依照中文的习惯进行了改写。

[译序]

    那些自认为已经“学完”C语言的人,请你们仔细读阅读这篇文章吧。路还长,很多东西要学。我也是……

[概述]

    C语言像一把雕刻刀,锋利,并且在技师手中非常有用。和任何锋利的工具一样,C会伤到那些不能掌握它的人。本文介绍C语言伤害粗心的人的方法,以及如何避免伤害。

[内容]

 

0 简介

    C语言及其典型实现被设计为能被专家们容易地使用。这门语言简洁并附有表达力。但有一些限制可以保护那些浮躁的人。一个浮躁的人可以从这些条款中获得一些帮助。

    在本文中,我们将会看到这些未可知的益处。正是由于它的未可知,我们无法为其进行完全的分类。不过,我们仍然通过研究为了一个C程序的运行所需要做的事来做到这些。我们假设读者对C语言至少有个粗浅的了解。

    第一部分研究了当程序被划分为记号时会发生的问题。第二部分继续研究了当程序的记号被编译器组合为声明、表达式和语句时会出现的问题。第三部分研究了由多个部分组成、分别编译并绑定到一起的C程序。第四部分处理了概念上的误解:当一个程序具体执行时会发生的事情。第五部分研究了我们的程序和它们所使用的常用库之间的关系。在第六部分中,我们注意到了我们所写的程序也许并不是我们所运行的程序;预处理器将首先运行。最后,第七部分讨论了可移植性问题:一个能在一个实现中运行的程序无法在另一个实现中运行的原因。

1 词法缺陷

    编译器的第一个部分常被称为词法分析器(lexical analyzer)。词法分析器检查组成程序的字符序列,并将它们划分为记号(token)一个记号是一个由一个或多个字符构成的序列,它在语言被编译时具有一个(相关地)统一的意义。在C中, 例如,记号->的意义和组成它的每个独立的字符具有明显的区别,而且其意义独立于->出现的上下文环境。

    另外一个例子,考虑下面的语句:

if(x > big) big = x;

该语句中的每一个分离的字符都被划分为一个记号,除了关键字if和标识符big的两个实例。

    事实上,C程序被两次划分为记号。首先是预处理器读取程序。它必须对程序进行记号划分以发现标识宏的标识符。它必须通过对每个宏进行求值来替换宏调用。最后,经过宏替换的程序又被汇集成字符流送给编译器。编译器再第二次将这个流划分为记号。

    在这一节中,我们将探索对记号的意义的普遍的误解以及记号和组成它们的字符之间的关系。稍后我们将谈到预处理器。

1.1 = 不是 ==

    从Algol派生出来的语言,如Pascal和Ada,用:=表示赋值而用=表示比较。而C语言则是用=表示赋值而用==表示比较。这是因为赋值的频率要高于比较,因此为其分配更短的符号。

    此外,C还将赋值视为一个运算符,因此可以很容易地写出多重赋值(如a = b = c),并且可以将赋值嵌入到一个大的表达式中。

    这种便捷导致了一个潜在的问题:可能将需要比较的地方写成赋值。因此,下面的语句好像看起来是要检查x是否等于y

if(x = y)
    foo();

而实际上是将x设置为y的值并检查结果是否非零。再考虑下面的一个希望跳过空格、制表符和换行符的循环:

while(c == ' ' || c = '\t' || c == '\n')
    c = getc(f);

在与'\t'进行比较的地方程序员错误地使用=代替了==。这个“比较”实际上是将'\t'赋给c,然后判断c的(新的)值是否为零。因为'\t'不为零,这个“比较”将一直为真,因此这个循环会吃尽整个文件。这之后会发生什么取决于特定的实现是否允许一个程序读取超过文件尾部的部分。如果允许,这个循环会一直运行。

    一些C编译器会对形如e1 = e2的条件给出一个警告以提醒用户。当你确实需要先对一个变量进行赋值之后再检查变量是否非零时,为了在这种编译器中避免警告信息,应考虑显式给出比较符。换句话说,将:

if(x = y)
    foo();

改写为:

if((x = y) != 0)
    foo();

这样可以清晰地表示你的意图。

1.2 &| 不是 &&||

    容易将==错写为=是因为很多其他语言使用=表示比较运算。 其他容易写错的运算符还有&&&,以及|||,这主要是因为C语言中的&|运算符于其他语言中具有类似功能的运算符大为不同。我们将在第4节中贴近地观察这些运算符。

1.3 多字符记号

    一些C记号,如/*=只有一个字符。而其他一些C记号,如/*==,以及标识符,具有多个字符。当C编译器遇到紧连在一起的/*时,它必须能够决定是将这两个字符识别为两个分离的记号还是一个单独的记号。C语言参考手册说明了如何决定:“如果输入流到一个给定的字符串为止已经被识别为记号,则应该包含下一个字符以组成能够构成记号的最长的字符串”([译注]即通常所说的“最长子串原则”)。因此,如果/是一个记号的第一个字符,并且/后面紧随了一个*,则这两个字符构成了注释的开始,不管其他上下文环境。

    下面的语句看起来像是将y的值设置为x的值除以p所指向的值:

y = x/*p    /* p 指向除数 */;

实际上,/*开始了一个注释,因此编译器简单地吞噬程序文本,直到*/的出现。换句话说,这条语句仅仅把y的值设置为x的值,而根本没有看到p。将这条语句重写为:

y = x / *p    /* p 指向除数 */;

或者干脆是

y = x / (*p)    /* p指向除数 */;

它就可以做注释所暗示的除法了。

    这种模棱两可的写法在其他环境中就会引起麻烦。例如,老版本的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

不是同义词。

    另一方面,有些老式编译器还是将=+视为一个单独的记号并且和+=是同义词。

1.5 字符串和字符

    单引号和双引号在C中的意义完全不同,在一些混乱的上下文中它们会导致奇怪的结果而不是错误消息。

    包围在单引号中的一个字符只是编写整数的另一种方法。这个整数是给定的字符在实现的对照序列中的一个对应的值。因此,在一个ASCII实现中,'a'和0141或97表示完全相同的东西。而一个包围在双引号中的字符串,只是编写一个有双引号之间的字符和一个附加的二进制值为零的字符所初始化的一个无名数组的指针的一种简短方法。

    下面的两个程序片断是等价的:

printf("Hello world\n");

char hello[] = { 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\n', 0 };
printf(hello);

    使用一个指针来代替一个整数通常会得到一个警告消息(反之亦然),使用双引号来代替单引号也会得到一个警告消息(反之亦然)。但对于不检查参数类型的编译器却除外。因此,用

printf('\n');

来代替

printf("\n");

通常会在运行时得到奇怪的结果。([译注]提示:正如上面所说,'\n'表示一个整数,它被转换为了一个指针,这个指针所指向的内容是没有意义的。)

    由于一个整数通常足够大,以至于能够放下多个字符,一些C编译器允许在一个字符常量中存放多个字符。这意味着用'yes'代替"yes"将不会被发现。后者意味着“分别包含yes和一个空字符的四个连续存储器区域中的第一个的地址”,而前者意味着“在一些实现定义的样式中表示由字符yes联合构成的一个整数”。这两者之间的任何一致性都纯属巧合。

2 句法缺陷

    要理解C语言程序,仅了解构成它的记号是不够的。还要理解这些记号是如何构成声明、表达式、语句和程序的。尽管这些构成通常都是定义良好的,但这些定义有时候是有悖于直觉的或混乱的。

    在这一节中,我们将着眼于一些不明显句法构造。

2.1 理解声明

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

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

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

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

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

float f, g;

说明表达式fg——在求值的时候——具有类型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]

    假设你有两个整型变量,hl,它们的值在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)++

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

  1. 所有的逻辑运算符具有比所有关系运算符都低的优先级。
  2. 移位运算符比关系运算符绑定得更紧密,但又不如数学运算符。

    在这些运算符类别中,有一些奇怪的地方。乘法、除法和求余具有相同的优先级,加法和减法具有相同的优先级,以及移位运算符具有相同的优先级。

    还有就是六个关系运算符并不具有相同的优先级:==!=的优先级比其他关系运算符要低。这就允许我们判断ab是否具有与cd相同的顺序,例如:

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是否与STRTYUNIONTY相等。而实际的效果却大不相同[3]

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

2.3 看看这些分号!

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

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

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

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

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

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

也就是等价于:

big = x[i];

(除非xibig是带有副作用的宏)。

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

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打印redyellowblue(没有新行符)。这两个程序片段非常相似,只有一点不同: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 = 0x != 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);
}

3 连接

    一个C程序可能有很多部分组成,它们被分别编译,并由一个通常称为连接器、连接编辑器或加载器的程序绑定到一起。由于编译器一次通常只能看到一个文件,因此它无法检测到需要程序的多个源文件的内容才能发现的错误。

    在这一节中,我们将看到一些这种类型的错误。有一些C实现,但不是所有的,带有一个称为lint的程序来捕获这些错误。如果具有一个这样的程序,那么无论怎样地强调它的重要性都不过分。

3.1 你必须自己检查外部类型

    假设你有一个C程序,被划分为两个文件。其中一个包含如下声明:

int n;

而令一个包含如下声明:

long n;

这不是一个有效的C程序,因为一些外部名称在两个文件中被声明为不同的类型。然而,很多实现检测不到这个错误,因为编译器在编译其中一个文件时并不知道另一个文件的内容。因此,检查类型的工作只能由连接器(或一些工具程序如lint)来完成;如果操作系统的连接器不能识别数据类型,C编译器也没法过多地强制它。

    那么,这个程序运行时实际会发生什么?这有很多可能性:

  1. 实现足够聪明,能够检测到类型冲突。则我们会得到一个诊断消息,说明n在两个文件中具有不同的类型。
  2. 你所使用的实现将intlong视为相同的类型。典型的情况是机器可以自然地进行32位运算。在这种情况下你的程序或许能够工作,好象你两次都将变量声明为long(或int)。但这种程序的工作纯属偶然。
  3. n的两个实例需要不同的存储,它们以某种方式共享存储区,即对其中一个的赋值对另一个也有效。这可能发生,例如,编译器可以将int安排在long的低位。不论这是基于系统的还是基于机器的,这种程序的运行同样是偶然。
  4. n的两个实例以另一种方式共享存储区,即对其中一个赋值的效果是对另一个赋以不同的值。在这种情况下,程序可能失败。

    这种情况发生的里一个例子出奇地频繁。程序的某一个文件包含下面的声明:

char filename[] = "etc/passwd";

而另一个文件包含这样的声明:

char *filename;

    尽管在某些环境中数组和指针的行为非常相似,但它们是不同的。在第一个声明中,filename是一个字符数组的名字。尽管使用数组的名字可以产生数组第一个元素的指针,但这个指针只有在需要的时候才产生并且不会持续。在第二个声明中,filename是一个指针的名字。这个指针可以指向程序员让它指向的任何地方。如果程序员没有给它赋一个值,它将具有一个默认的0值(NULL)([译注]实际上,在C中一个为初始化的指针通常具有一个随机的值,这是很危险的!)。

    这两个声明以不同的方式使用存储区,它们不可能共存。

    避免这种类型冲突的一个方法是使用像lint这样的工具(如果可以的话)。为了在一个程序的不同编译单元之间检查类型冲突,一些程序需要一次看到其所有部分。典型的编译器无法完成,但lint可以。

    避免该问题的另一种方法是将外部声明放到包含文件中。这时,一个外部对象的类型仅出现一次[7]

4 语义缺陷

    一个句子可以是精确拼写的并且没有语法错误,但仍然没有意义。在这一节中,我们将会看到一些程序的写法会使得它们看起来是一个意思,但实际上是另一种完全不同的意思。

    我们还要讨论一些表面上看起来合理但实际上会产生未定义结果的环境。我们这里讨论的东西并不保证能够在所有的C实现中工作。我们暂且忘记这些能够在一些实现中工作但可能不能在另一些实现中工作的东西,直到第7节讨论可以执行问题为止。

4.1 表达式求值顺序

    一些C运算符以一种已知的、特定的顺序对其操作数进行求值。但另一些不能。例如,考虑下面的表达式:

a < b && c < d

C语言定义规定a < b首先被求值。如果a确实小于bc < d必须紧接着被求值以计算整个表达式的值。但如果a大于或等于b,则c < d根本不会被求值。

    要对a < b求值,编译器对ab的求值就会有一个先后。但在一些机器上,它们也许是并行进行的。

    C中只有四个运算符&&||?:,指定了求值顺序。&&||最先对左边的操作数进行求值,而右边的操作数只有在需要的时候才进行求值。而?:运算符中的三个操作数:abc,最先对a进行求值,之后仅对bc中的一个进行求值,这取决于a的值。,运算符首先对左边的操作数进行求值,然后抛弃它的值,对右边的操作数进行求值[8]

    C中所有其它的运算符对操作数的求值顺序都是未定义的。事实上,赋值运算符不对求值顺序做出任何保证。

    出于这个原因,下面这种将数组x中的前n个元素复制到数组y中的方法是不可行的:

i = 0;
while(i < n)
    y[i] = x[i++];

其中的问题是y[i]的地址并不保证在i增长之前被求值。在某些实现中,这是可能的;但在另一些实现中却不可能。另一种情况出于同样的原因会失败:

i = 0;
while(i < n)
    y[i++] = x[i];

而下面的代码是可以工作的:

i = 0;
while(i < n) {
    y[i] = x[i];
    i++;
}

当然,这可以简写为:

for(i = 0; i < n; i++)
    y[i] = x[i];

4.2 &&||!运算符

    C中有两种逻辑运算符,在某些情况下是可以交换的:按位运算符&|~,以及逻辑运算符&&||!。一个程序员如果用某一类运算符替换相应的另一类运算符会得到某些奇怪的效果:程序可能会正确地工作,但这纯属偶然。

    &&||!运算符将它们的参数视为仅有

分享到:
评论

相关推荐

    C语言缺陷与陷阱(笔记).txt

    ### C语言缺陷与陷阱解析 #### 一、概述 C语言作为一门历史悠久且应用广泛的编程语言,在实际开发过程中,存在着不少容易让人忽视的缺陷和陷阱。本文将对这些缺陷和陷阱进行详细的分析,并提供相应的解决方案。 #...

    C语言缺陷与陷阱(笔记)

    从给定的内容中,虽然信息显得杂乱无章,但我们仍可以提取出关于...对于学习C语言的同学们,通过阅读这类“C语言缺陷与陷阱”的资料笔记,能够更好地理解C语言的特性,并学会如何安全、高效地使用这种强大的编程语言。

    C语言缺陷与陷阱(笔记).doc

    《C语言缺陷与陷阱》笔记概述 C语言作为一种强大的编程工具,因其低级特性而备受程序员喜爱,但也因其潜在的缺陷和陷阱而让初学者困惑。这篇笔记详细探讨了C语言在不同层面可能存在的问题,旨在帮助开发者更好地...

    c语言缺陷与陷阱(笔记)

    这是我在阅读的时候记录的经典的东西哦!希望大家可以从中学的到很多自己想要的东西啊!在这里希望大家学习愉快!

    C语言陷阱和缺陷与读书笔记word档

    这份"**C语言陷阱和缺陷与读书笔记word档**"正是为了帮助初学者避开这些潜在问题而编写的。 一、内存管理 在C语言中,程序员需要手动管理内存,这可能导致内存泄漏或野指针。当忘记释放已分配的内存时,就会发生...

    C语言陷阱与缺陷(学习笔记)

    《C语言陷阱与缺陷》的学习笔记详尽剖析了C语言中容易导致问题的特性,旨在帮助程序员避免潜在的陷阱。C语言以其强大的低级控制能力著称,但也因其语法细节和一些非直观的设计而闻名。以下是对笔记内容的详细解释: ...

    c语言的陷阱与学习笔记

    《C语言的陷阱与学习笔记》是一份深入探讨C语言中常见问题和陷阱的资料,对于各个层次的学习者都极具价值。C语言以其简洁、高效和灵活性著称,但也因此存在许多容易导致错误的特性,对于初学者和经验丰富的程序员来...

    c缺陷与陷阱(笔记2)

    《C缺陷与陷阱》的学习笔记揭示了C语言中的一些常见陷阱和理解难点,这些细节对于初学者来说可能不易察觉,但对于提升编程技能至关重要。以下是对笔记中提到的一些关键知识点的详细解释: 1. **词法陷阱** - `=` ...

    c缺陷与陷阱(笔记)

    C语言是一种底层编程语言,以其灵活性和效率著称,但同时也因为其低级特性而充满了潜在的缺陷和陷阱。在编程过程中,理解这些缺陷和陷阱是避免错误的关键。 首先,我们要明白C语言中的赋值运算符`=`和比较运算符`==...

    C缺陷与陷阱(笔记)

    【C缺陷与陷阱】这篇笔记主要探讨了C语言中容易造成误解和问题的特性,旨在帮助程序员避免因不熟悉语言细节而引发的错误。以下是笔记的主要内容概览: 1. **词法缺陷**: - **= 不是 ==**:在C语言中,单个等号`=`...

    C陷阱与缺陷读书笔记整理

    《C陷阱与缺陷》是一本深入探讨C语言潜在问题的经典著作,它揭示了在编程过程中容易忽视或误解的陷阱和缺陷。以下是对书籍内容的详细梳理: ### 一、词法陷阱 1. **`=` 不同于 `==`**:在C语言中,`=`是赋值运算符...

    C语言难点分析整理

    23. C语言缺陷与陷阱(笔记) 119 24. C语言防止缓冲区溢出方法 126 25. C语言高效编程秘籍 128 26. C运算符优先级口诀 133 27. do/while(0)的妙用 134 28. exit()和return()的区别 140 29. exit子程序终止函数与...

    C语言学习资料C语言技术编程经验分享C指针经验总结资料合集(25个).zip

    C语言学习资料C语言技术编程经验分享C指针经验总结资料合集(25个): c99标准.pdf C指针经验总结.pdf C程序设计语言.pdf ...《C陷阱与缺陷》学习笔记.txt 一份不错的C语言指针教程.pdf 再再论指针.pdf

    高级C语言.PDF

    C语言缺陷与陷阱(笔记) ............................................................................................................ 107 24. C语言防止缓冲区溢出方法 .......................................

    免费下载:C语言难点分析整理.doc

    C语言缺陷与陷阱(笔记) 这部分记录了C语言中容易忽略的细节和潜在的问题。 ### 24. C语言防止缓冲区溢出方法 缓冲区溢出是安全漏洞的主要来源之一,可以通过仔细检查输入和限制写入范围来预防。 ### 25. C语言...

    高级C语言 学完C语言来看这个绝对收获

    C语言缺陷与陷阱 C语言中的一些陷阱包括: - **类型转换不一致**:不同数据类型间的隐式转换可能导致意外的结果。 - **数组和指针混淆**:在某些情况下,数组和指针的行为相似,但在其他情况下则不同。 #### 22....

    高级进阶c语言教程..doc

    C语言缺陷与陷阱(笔记) 了解 C 语言中的一些潜在陷阱可以帮助开发者避免常见的错误。 - **未定义行为**:如除数为零的情况 - **序列点问题**:在同一表达式中修改同一个变量多次 - **类型转换问题**:隐式类型...

    超好的ARM&Linux学习资料(菜鸟1年多笔记总结)

    - **《C陷阱与缺陷》读书笔记** - 解析了C语言中常见的陷阱和错误,并提供了避免这些错误的方法。 - **《上交大C++视频教程》读书笔记** - 介绍了C++的基础语法和面向对象编程的概念。 - **《Linux程序设计》读书...

Global site tag (gtag.js) - Google Analytics