《C Traps and Pitfalls》 笔记
这本书短短的100多页，很象是一篇文章。但是指出的很多问题的确容易出现在笔试的改错题中
--------------------------------------------------------------------
第1章 词法陷阱
1.1 = 和 ==
1.3 词法分析的"贪心法则"
编译器从左到右读入字符，每个符号包含尽可能多的字符，直到不是字符为止
如：
a---b 等价于 a-- - b
a/*b 并不是 a/(*b), 而是/*当作注释符
1.4 整型常量
0开头的整数为8进制
如：
014 为8进制， 不要误看作10进制
1.5 字符和字符串
单引号 － ASCII字符，实际上是一个整数
双引号 － 指向匿名的字符数组起始字符的指针，该数组以引用的字符和额外的'\0'初始化
另外，大多数编译器允许一个字符常量中包含多个字符。Borland C++中只取第一个字符，而VC 6.0和GCC中则后面的字符依次覆盖前面的字符，最后得到的是最后一个字符。
如：(GCC 3.5)
char ch='yes';
cout << ch;//output: s, but with warning
练习题：
1-1。某些C编译器允许嵌套注释。请写一个测试程序，要求：无论对是否允许嵌套注释的编译器，该程序都能正常通过编译（无错误消息），但是这两种情况下程序执行的结果却不同。
1-3. n-->0的含义？
(n--) > 0 贪心法则
1-4 a+++++b的含义?
((a++) ++) + b
但是值得一提的是：现代编译器中，此式子是非法的
为什么？
你可以查看operator++(int)的原型： const int operator++(int)
返回的为const型，且为a的临时拷贝。之所以返回为const型，就是为了将返回作为左值，也就防止出现这类式子
总结：a++不能做左值
---------------------------------------------------------------------------------------
第2章 语法陷阱
2.1 理解函数声明
换个角度理解声明语句(declaration)
声明语句构成：类型 + 一组类似表达式的声明符(declarator)
float f, g; //表达式f, g求值为浮点数，即f, g为浮点型
float ff(); //表达式ff()求值是一个浮点数，即ff是一个返回类型为浮点数的函数
float *pf; //*pf求值是一个浮点数，即pf是指向浮点型的指针
更复杂的，
float *g(), (*h)();
依据上述并且()优先级大于*，很容易知道g是一个函数，返回类型为浮点指针（float *）
h为一个函数指针，函数返回类型为float
(float (*h)()) 是一个类型转换符
再看：
（*(void(*)())0)()
实质上是：
void (*fp)(); //declare a function pointer
typedef void (*fp_type)();// for simplifying, otherwise always need void(*)()
conv_0 = (fp_type)0; // converse function 0 into function conv_o
(*conv_0)();//using the conversed function
再让我们看看<signal.h>中声明的signal函数
void (*signal(int, void(*)(int)))(int)
首先，用typedef简化，
typedef void (*handler_type)(int)
得，void (*signal(int, handler_type))(int)
进一步 handler_type signal(int, handler_type);
2.3 作为语句结束的分号
1）多写了分号
if(x[i] > big);
big = x[i]
这还是很容易辨识
再看
2）漏写了分号
继续看下面一个经典的：
注：这个问题笔试题已经出现过
2.4 swith语句
这个估计是老生常谈了
也就是case后的break有无的问题了
首先要搞清楚一件事：你可以把(case:)当作语句的标号，就好像汇编中的标号一样。switch之后径直跳到匹配的case处顺序执行下去，以后再碰到case则无视
当然，程序设计中有意不要break的除外
2.6 “空悬”else引发的问题
看下面代码：
防止这类问题很简单，只要每次使用if，else都用｛｝
---------------------------------------------------------
第3章 语义陷阱
3.1 指针和数组
C语言数组需要注意：
1）C语言只有一维数组，数组大小必须在编译期确定为常数。二维数组是通过数组元素也为数组的一维数组实现
2）对于一个数组，只能做2件事情：确定数组大小，取得指向数组首元素的指针。其他相关操作，如下标运算， 都是通过指针进行
int a[3]; //数组元素为int型
struct
{
int p[4];
double x;
}b[17]; //数组元素为结构体
int calendar[12][31];
//12个元素的数组，每个元素又是31元素的数组
//并非：31个元素的数组，每个元素是12个元素的数组
记住：数组名是指向该数组首元素的指针
如，int a[11]; //那么a的类型为 (int *)
int *ptr;
ptr = a;
但是ptr = &a;是非法的，这里&a的类型为int (*)[],即指向数组的指针，大多数编译期对这种操作，或者视为非法，或者让其等于a
在C中，a+i和i+a的含义是一样的，但后者不推荐
下面看多维数组：
int calendar[12][31];
int *p;
int i;
我们很容易知道calendar[4]表示什么含义：calendar[4]表示calendar数组的第5个元素，是12个有31个元素的数组之一。
sizeof(calendar[4])结果为31×sizeof(int)
此例中，calendar名字转换为一个指向数组的指针，其类型为int (*)[31]
于是p=calendar; 是非法的
int (*monthp)[31];
monthp = calendar;//OK
calendar[month][day] = 0;
等价于
*(*(calendar+month)+day) = 0;
怎样分析这个呢?
首先，calendar+month是指向12个元素之一的指针，对其解引用得到就是其元素(而元素是数组)，所以*(calendar+month)是指向含31个元素的数组首元素的指针，再偏移然后解引用即得到最终的int型元素
总结：
1）数组名表示指向首元素的指针，类型为元素类型的指针
2) 对数组名取地址，为指向数组的指针，类型为数组的指针
3.2 非数组的指针 － 字符串
字符串常量：代表一块包含字符串中所有字符加上额外一个空字符('\0')的内存区的地址。
一般字符串常量用字符数组保存的，且是只读的。
字符串操作函数：
size_t strlen(char *);//计算字符串长度，直到遇到'\0'.且不包括'\0'
int strcpy(char * dest, const char *src);
int strcat(char *dest, char *src);
注意其中的输出参数dest必须是预先分配好，且有足够的空间能容纳
3.3 数组作为函数参数
自动转换成指针
3.6 边界计算与不对称边界
这个主题值得探讨
3.7 求值顺序
C中只有四个运算符(&&, ||, ? :和,)规定了求值顺序，对于其他运算符不要错误的假设求值顺序，他们求值顺序是未定义的。
如：
i = 0;
while(i < n)
y[i] = x[i++];
这里y[i]的地址在i自增前被求值是没有任何保证的
3.9 整数溢出
C语言中存在2类整数算术运算：有符号运算与无符号运算。
两个无符号数运算不存在溢出。
算术运算中一个是有符号数，另一个是无符号数，则有符号数会转换为无符号数，运算时溢出也不可能发生。
两个有符号数运算，溢出有可能发生。并且溢出发生时，溢出结果是未定义的。
那么如何检测是否发生溢出呢？
看下面的方式：
int a, b;
if(a + b < 0)
//do something
这种方式是不可靠的，因为对溢出结果做的任何假设都是不可靠的
正确的方式：
#include <limits.h>
int a, b;
if((unsigned)a + (unsigned)b > INT_MAX)
//...
或者
if(a > INT_MAX - b)
//...
--------------------------------------------------------------------------------------
第4章 连接
4.2 声明与定义
下面声明语句：
int a;
如果出现在所有函数体(包括main函数)之外, 它被成为外部对象a的定义，并且其初始值默认为0
下面声明语句：
int a = 7;
定义a的同时指定了初始值
下面声明语句：
extern int a;
并不是a的定义，说明a是一个外部整型变量，它的存储空间在程序的其他地方分配
典型情况：
//file1.c
int a = 7;
//file2.c
int a = 9;
这种情况一般在连接时会报错，因为定义只能一次，声明却可以很多
4.3 命名冲突与static修饰符
static将变量或函数的作用域限定在一个源文件中了
4.5 检查外部变量
--------------------------------------------------------------------
第1章 词法陷阱
1.1 = 和 ==
1.3 词法分析的"贪心法则"
编译器从左到右读入字符，每个符号包含尽可能多的字符，直到不是字符为止
如：
a---b 等价于 a-- - b
a/*b 并不是 a/(*b), 而是/*当作注释符
1.4 整型常量
0开头的整数为8进制
如：
014 为8进制， 不要误看作10进制
1.5 字符和字符串
单引号 － ASCII字符，实际上是一个整数
双引号 － 指向匿名的字符数组起始字符的指针，该数组以引用的字符和额外的'\0'初始化
另外，大多数编译器允许一个字符常量中包含多个字符。Borland C++中只取第一个字符，而VC 6.0和GCC中则后面的字符依次覆盖前面的字符，最后得到的是最后一个字符。
如：(GCC 3.5)
char ch='yes';
cout << ch;//output: s, but with warning
练习题：
1-1。某些C编译器允许嵌套注释。请写一个测试程序，要求：无论对是否允许嵌套注释的编译器，该程序都能正常通过编译（无错误消息），但是这两种情况下程序执行的结果却不同。
1-3. n-->0的含义？
(n--) > 0 贪心法则
1-4 a+++++b的含义?
((a++) ++) + b
但是值得一提的是：现代编译器中，此式子是非法的
为什么？
你可以查看operator++(int)的原型： const int operator++(int)
返回的为const型，且为a的临时拷贝。之所以返回为const型，就是为了将返回作为左值，也就防止出现这类式子
总结：a++不能做左值
---------------------------------------------------------------------------------------
第2章 语法陷阱
2.1 理解函数声明
换个角度理解声明语句(declaration)
声明语句构成：类型 + 一组类似表达式的声明符(declarator)
float f, g; //表达式f, g求值为浮点数，即f, g为浮点型
float ff(); //表达式ff()求值是一个浮点数，即ff是一个返回类型为浮点数的函数
float *pf; //*pf求值是一个浮点数，即pf是指向浮点型的指针
更复杂的，
float *g(), (*h)();
依据上述并且()优先级大于*，很容易知道g是一个函数，返回类型为浮点指针（float *）
h为一个函数指针，函数返回类型为float
(float (*h)()) 是一个类型转换符
再看：
（*(void(*)())0)()
实质上是：
void (*fp)(); //declare a function pointer
typedef void (*fp_type)();// for simplifying, otherwise always need void(*)()
conv_0 = (fp_type)0; // converse function 0 into function conv_o
(*conv_0)();//using the conversed function
再让我们看看<signal.h>中声明的signal函数
void (*signal(int, void(*)(int)))(int)
首先，用typedef简化，
typedef void (*handler_type)(int)
得，void (*signal(int, handler_type))(int)
进一步 handler_type signal(int, handler_type);
2.3 作为语句结束的分号
1）多写了分号
if(x[i] > big);
big = x[i]
这还是很容易辨识
再看
2）漏写了分号
if(n < 3)
return
logrec.date = x[0];
logrec.time = x[1];
logrec.code = x[2];
看出问题来了没？return
logrec.date = x[0];
logrec.time = x[1];
logrec.code = x[2];
继续看下面一个经典的：
struct logrec
{
int date;
int time;
int code;
}
main()
{
//
}
{
int date;
int time;
int code;
}
main()
{
//
}
注：这个问题笔试题已经出现过
2.4 swith语句
这个估计是老生常谈了
也就是case后的break有无的问题了
首先要搞清楚一件事：你可以把(case:)当作语句的标号，就好像汇编中的标号一样。switch之后径直跳到匹配的case处顺序执行下去，以后再碰到case则无视
当然，程序设计中有意不要break的除外
2.6 “空悬”else引发的问题
看下面代码：
if(x == 0)
if(y == 0) error();
else{
z = x + y;
f(&z);
}
这段代码可能与你的本意大相径庭，因为else与最近的if匹配if(y == 0) error();
else{
z = x + y;
f(&z);
}
防止这类问题很简单，只要每次使用if，else都用｛｝
---------------------------------------------------------
第3章 语义陷阱
3.1 指针和数组
C语言数组需要注意：
1）C语言只有一维数组，数组大小必须在编译期确定为常数。二维数组是通过数组元素也为数组的一维数组实现
2）对于一个数组，只能做2件事情：确定数组大小，取得指向数组首元素的指针。其他相关操作，如下标运算， 都是通过指针进行
int a[3]; //数组元素为int型
struct
{
int p[4];
double x;
}b[17]; //数组元素为结构体
int calendar[12][31];
//12个元素的数组，每个元素又是31元素的数组
//并非：31个元素的数组，每个元素是12个元素的数组
记住：数组名是指向该数组首元素的指针
如，int a[11]; //那么a的类型为 (int *)
int *ptr;
ptr = a;
但是ptr = &a;是非法的，这里&a的类型为int (*)[],即指向数组的指针，大多数编译期对这种操作，或者视为非法，或者让其等于a
在C中，a+i和i+a的含义是一样的，但后者不推荐
下面看多维数组：
int calendar[12][31];
int *p;
int i;
我们很容易知道calendar[4]表示什么含义：calendar[4]表示calendar数组的第5个元素，是12个有31个元素的数组之一。
sizeof(calendar[4])结果为31×sizeof(int)
此例中，calendar名字转换为一个指向数组的指针，其类型为int (*)[31]
于是p=calendar; 是非法的
int (*monthp)[31];
monthp = calendar;//OK
calendar[month][day] = 0;
等价于
*(*(calendar+month)+day) = 0;
怎样分析这个呢?
首先，calendar+month是指向12个元素之一的指针，对其解引用得到就是其元素(而元素是数组)，所以*(calendar+month)是指向含31个元素的数组首元素的指针，再偏移然后解引用即得到最终的int型元素
总结：
1）数组名表示指向首元素的指针，类型为元素类型的指针
2) 对数组名取地址，为指向数组的指针，类型为数组的指针
3.2 非数组的指针 － 字符串
字符串常量：代表一块包含字符串中所有字符加上额外一个空字符('\0')的内存区的地址。
一般字符串常量用字符数组保存的，且是只读的。
字符串操作函数：
size_t strlen(char *);//计算字符串长度，直到遇到'\0'.且不包括'\0'
int strcpy(char * dest, const char *src);
int strcat(char *dest, char *src);
注意其中的输出参数dest必须是预先分配好，且有足够的空间能容纳
3.3 数组作为函数参数
自动转换成指针
3.6 边界计算与不对称边界
这个主题值得探讨
3.7 求值顺序
C中只有四个运算符(&&, ||, ? :和,)规定了求值顺序，对于其他运算符不要错误的假设求值顺序，他们求值顺序是未定义的。
如：
i = 0;
while(i < n)
y[i] = x[i++];
这里y[i]的地址在i自增前被求值是没有任何保证的
3.9 整数溢出
C语言中存在2类整数算术运算：有符号运算与无符号运算。
两个无符号数运算不存在溢出。
算术运算中一个是有符号数，另一个是无符号数，则有符号数会转换为无符号数，运算时溢出也不可能发生。
两个有符号数运算，溢出有可能发生。并且溢出发生时，溢出结果是未定义的。
那么如何检测是否发生溢出呢？
看下面的方式：
int a, b;
if(a + b < 0)
//do something
这种方式是不可靠的，因为对溢出结果做的任何假设都是不可靠的
正确的方式：
#include <limits.h>
int a, b;
if((unsigned)a + (unsigned)b > INT_MAX)
//...
或者
if(a > INT_MAX - b)
//...
--------------------------------------------------------------------------------------
第4章 连接
4.2 声明与定义
下面声明语句：
int a;
如果出现在所有函数体(包括main函数)之外, 它被成为外部对象a的定义，并且其初始值默认为0
下面声明语句：
int a = 7;
定义a的同时指定了初始值
下面声明语句：
extern int a;
并不是a的定义，说明a是一个外部整型变量，它的存储空间在程序的其他地方分配
典型情况：
//file1.c
int a = 7;
//file2.c
int a = 9;
这种情况一般在连接时会报错，因为定义只能一次，声明却可以很多
4.3 命名冲突与static修饰符
static将变量或函数的作用域限定在一个源文件中了
4.5 检查外部变量
