很酷的C语言技巧

C语言常常让人觉得它所能表达的东西非常有限。它不具有类似第一级函数和模式匹配这样的高级功能。但是C非常简单，并且仍然有一些非常有用的语法技巧和功能，只是没有多少人知道罢了。

指定的初始化

很多人都知道像这样来静态地初始化数组：

1
int fibs[] = {1, 1, 2, 3, 5};
C99标准实际上支持一种更为直观简单的方式来初始化各种不同的集合类数据（如：结构体，联合体和数组）。

 

数组

我们可以指定数组的元素来进行初始化。这非常有用，特别是当我们需要根据一组#define来保持某种映射关系的同步更新时。来看看一组错误码的定义，如：

1
2
3
4
5
6
7
8
9
10
/* Entries may not correspond to actual numbers. Some entries omitted. */
#define EINVAL 1
#define ENOMEM 2
#define EFAULT 3
/* ... */
#define E2BIG 7
#define EBUSY 8
/* ... */
#define ECHILD 12
/* ... */
现在，假设我们想为每个错误码提供一个错误描述的字符串。为了确保数组保持了最新的定义，无论头文件做了任何修改或增补，我们都可以用这个数组指定的语法。

1
2
3
4
5
6
7
8
9
10
11
12
char *err_strings[] = {
[0] = "Success",
[EINVAL] = "Invalid argument",
[ENOMEM] = "Not enough memory",
[EFAULT] = "Bad address",
/* ... */
[E2BIG ] = "Argument list too long",
[EBUSY ] = "Device or resource busy",
/* ... */
[ECHILD] = "No child processes"
/* ... */
};
这样就可以静态分配足够的空间，且保证最大的索引是合法的，同时将特殊的索引初始化为指定的值，并将剩下的索引初始化为0。

Cool C Tricks
（伯乐在线配图）
 

结构体与联合体

1
用结构体与联合体的字段名称来初始化数据是非常有用的。假设我们定义：
1
2
3
4
5
struct point {
int x;
int y;
int z;
}
1
然后我们这样初始化struct point：
1
struct point p = {.x = 3, .y = 4, .z = 5};
当我们不想将所有字段都初始化为0时，这种作法可以很容易的在编译时就生成结构体，而不需要专门调用一个初始化函数。

对联合体来说，我们可以使用相同的办法，只是我们只用初始化一个字段。

 

宏列表

C中的一个惯用方法，是说有一个已命名的实体列表，需要为它们中的每一个建立函数，将它们中的每一个初始化，并在不同的代码模块中扩展它们的名字。这在Mozilla的源码中经常用到，我就是在那时学到这个技巧的。例如，在我去年夏天工作的那个项目中，我们有一个针对每个命令进行标记的宏列表。其工作方式如下：

1
2
3
4
5
6
7
8
#define FLAG_LIST(_) 
_(InWorklist) 
_(EmittedAtUses) 
_(LoopInvariant) 
_(Commutative) 
_(Movable) 
_(Lowered) 
_(Guard)
它定义了一个FLAG_LIST宏，这个宏有一个参数称之为 _ ，这个参数本身是一个宏，它能够调用列表中的每个参数。举一个实际使用的例子可能更能直观地说明问题。假设我们定义了一个宏DEFINE_FLAG，如：

1
2
3
4
5
6
7
#define DEFINE_FLAG(flag) flag,
enum Flag {
None = 0,
FLAG_LIST(DEFINE_FLAG)
Total
};
#undef DEFINE_FLAG
对FLAG_LIST(DEFINE_FLAG)做扩展能够得到如下代码：

1
2
3
4
5
6
7
8
9
10
11
enum Flag {
None = 0,
DEFINE_FLAG(InWorklist)
DEFINE_FLAG(EmittedAtUses)
DEFINE_FLAG(LoopInvariant)
DEFINE_FLAG(Commutative)
DEFINE_FLAG(Movable)
DEFINE_FLAG(Lowered)
DEFINE_FLAG(Guard)
Total
};
接着，对每个参数都扩展DEFINE_FLAG宏，这样我们就得到了enum如下：

1
2
3
4
5
6
7
8
9
10
11
enum Flag {
None = 0,
InWorklist,
EmittedAtUses,
LoopInvariant,
Commutative,
Movable,
Lowered,
Guard,
Total
};
接着，我们可能要定义一些访问函数，这样才能更好的使用flag列表：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define FLAG_ACCESSOR(flag) 
bool is##flag() const {
return hasFlags(1 << flag);
}
void set##flag() {
JS_ASSERT(!hasFlags(1 << flag));
setFlags(1 << flag);
}
void setNot##flag() {
JS_ASSERT(hasFlags(1 << flag));
removeFlags(1 << flag);
}
 
FLAG_LIST(FLAG_ACCESSOR)
#undef FLAG_ACCESSOR
一步步的展示其过程是非常有启发性的，如果对它的使用还有不解，可以花一些时间在gcc –E上。

 

编译时断言

这其实是使用C语言的宏来实现的非常有“创意”的一个功能。有些时候，特别是在进行内核编程时，在编译时就能够进行条件检查的断言，而不是在运行时进行，这非常有用。不幸的是，C99标准还不支持任何编译时的断言。

但是，我们可以利用预处理来生成代码，这些代码只有在某些条件成立时才会通过编译（最好是那种不做实际功能的命令）。有各种各样不同的方式都可以做到这一点，通常都是建立一个大小为负的数组或结构体。最常用的方式如下：

1
2
3
4
5
6
7
8
9
/* Force a compilation error if condition is false, but also produce a result
* (of value 0 and type size_t), so it can be used e.g. in a structure
* initializer (or wherever else comma expressions aren't permitted). */
/* Linux calls these BUILD_BUG_ON_ZERO/_NULL, which is rather misleading. */
#define STATIC_ZERO_ASSERT(condition) (sizeof(struct { int:-!(condition); }) )
#define STATIC_NULL_ASSERT(condition) ((void *)STATIC_ZERO_ASSERT(condition) )
 
/* Force a compilation error if condition is false */
#define STATIC_ASSERT(condition) ((void)STATIC_ZERO_ASSERT(condition))
如果(condition)计算结果为一个非零值（即C中的真值），即! (condition)为零值，那么代码将能顺利地编译，并生成一个大小为零的结构体。如果(condition)结果为0（在C真为假），那么在试图生成一个负大小的结构体时，就会产生编译错误。

它的使用非常简单，如果任何某假设条件能够静态地检查，那么它就可以在编译时断言。例如，在上面提到的标志列表中，标志集合的类型为uint32_t，所以，我们可以做以下断言：

1
STATIC_ASSERT(Total <= 32)
它扩展为：

1
(void)sizeof(struct { int:-!(Total <= 32) })
现在，假设Total<=32。那么-!(Total <= 32)等于0，所以这行代码相当于：

1
(void)sizeof(struct { int: 0 })
这是一个合法的C代码。现在假设标志不止32个，那么-!(Total <= 32)等于-1，所以这时代码就相当于：

1
(void)sizeof(struct { int: -1 } )
因为位宽为负，所以可以确定，如果标志的数量超过了我们指派的空间，那么编译将会失败。

宏定义

本词条主要介绍 C++ 宏定义
C++ 宏定义将一个标识符定义为一个字符串，源程序中的该标识符均以指定的字符串来代替。前面已经说过，预处理命令不同于一般C++语句。因此预处理命令后通常不加分号。这并不是说所有的预处理命令后都不能有分号出现。由于宏定义只是用宏名对一个字符串进行简单的替换，因此如果在宏定义命令后加了分号，将会连同分号一起进行置换。
目录
三种预处理功能 
使用宏定义注意点 
带参数的宏定义形式 
使用带参数宏定义注意点
三种预处理功能
　　C++提供的编译预处理功能主要有以下三种： 
　　（一） 宏定义 
　　（二） 文件包含 
　　（三） 条件编译 
　　在C++中，我们一般用const定义符号常量。很显然，用const定义常量比用define定义常量更好。 
使用宏定义注意点
　　在使用宏定义时应注意的是： 
　　（a） 在书写#define 命令时，注意<宏名>和<字符串>之间用空格分开，而不是用等号连接。 
　　（b） 使用#define定义的标识符不是变量，它只用作宏替换，因此不占有内存。 
　　（c） 习惯上用大写字母表示<宏名>，这只是一种习惯的约定，其目的是为了与变量名区分，因为变量名 
　　通常用小写字母。 
　　如果某一个标识符被定义为宏名后，在取消该宏定义之前，不允许重新对它进行宏定义。取消宏定义使用如下命令： 
　　#undef<标识符> 
　　其中，undef是关键字。该命令的功能是取消对<标识符>已有的宏定义。被取消了宏定义的标识符，可以对它重新进行定义。 
　　宏定义可以嵌套，已被定义的标识符可以用来定义新的标识符。例如： 
　　#define PI 3.14159265 
　　#define R 10 
　　#define AREA (PI*R*R) 
带参数的宏定义形式
　　带参数的宏定义的一般形式如下： 
　　#define <宏名>（<参数表>） <宏体> 
　　其中， <宏名>是一个标识符，<参数表>中的参数可以是一个，也可以是多个，视具体情况而定，当有多个参数的时候，每个参数之间用逗号分隔。<宏体>是被替换用的字符串，宏体中的字符串是由参数表中的各个参数组成的表达式。例如： 
　　#define SUB(a,b) a-b 
　　如果在程序中出现如下语句： 
　　result=SUB(2, 3) 
　　则被替换为： 
　　result=2-3； 
　　如果程序中出现如下语句： 
　　result= SUB（x+1, y+2）; 
　　则被替换为： 
　　result=x+1-y+2; 
　　在这样的宏替换过程中，其实只是将参数表中的参数代入到宏体的表达式中去，上述例子中，即是将表达式中的a和b分别用2和3代入。 
　　我们可以发现：带参的宏定义与函数类似。如果我们把宏定义时出现的参数视为形参，而在程序中引用宏定义时出现的参数视为实参。那么上例中的a和b就是形参，而2和3以及x+1和y+2都为实参。在宏替换时，就是用实参来替换<宏体>中的形参。 
使用带参数宏定义注意点
　　在使用带参数的宏定义时需要注意的是： 
　　（1）带参数的宏定义的<宏体>应写在一行上，如果需要写在多行上时，在每行结束时，使用续行符 ""结 
　　束，并在该符号后按下回车键，最后一行除外。 
　　（2）在书写带参数的宏定义时，<宏名>与左括号之间不能出现空格，否则空格右边的部分都作为宏体。 
　　例如： 
　　#define ADD (x,y) x+y 
　　将会把"（x,y）x+y"的一个整体作为被定义的字符串。 
　　（3）定义带参数的宏时，宏体中与参数名相同的字符串适当地加上圆括号是十分重要的，这样能够避免 
　　可能产生的错误。例如,对于宏定义： 
　　#define SQ(x) x*x 
　　当程序中出现下列语句： 
　　m=SQ(a+b); 
　　替换结果为： 
　　m=a+b*a+b; 
　　这可能不是我们期望的结果，如果需要下面的替换结果： 
　　m=(a+b)*(a+b); 
　　应将宏定义修改为： 
　　#define SQ(x) (x)*(x) 
　　对于带参的宏定义展开置换的方法是：在程序中如果有带实参的宏（如"SUB（2,3）"），则按"#define"命令行中指定的字符串从左到右进行置换。如果串中包含宏中的形参（如a、b），则将程序语句中相应的实参（可以是常量、变量或者表达式）代替形参，如果宏定义中的字符串中的字符不是参数字符（如a-b中的-号），则保留。这样就形成了置换的字符串。

 

　　试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。
　　解答：
#define MIN(A,B) ((A) <= (B) ? (A) : (B))


宏定义
　　宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、条件编译 
1.不带参数的宏定义：
　　宏定义又称为宏代换、宏替换，简称“宏”。 
　　格式： 
　　#define 标识符 字符串 
　　其中的标识符就是所谓的符号常量，也称为“宏名”。 
　　预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。 
　　掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。 
　　即在对相关命令或语句的含义和功能作具体分析之前就要换： 
　　例： 
　　#define PI 3.1415926 
　　把程序中出现的PI全部换成3.1415926 
　　说明： 
　　（1）宏名一般用大写 
　　（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例如：数组大小常用宏定义 
　　（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法检查。 
　　（4）宏定义末尾不加分号； 
　　（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。 
　　（6）可以用#undef命令终止宏定义的作用域 
　　（7）宏定义可以嵌套 
　　（8）字符串" "中永远不包含宏 
　　（9）宏定义不分配内存，变量定义分配内存。 
2.带参数的宏定义：
　　除了一般的字符串替换，还要做参数代换 
　　格式： 
　　#define 宏名（参数表） 字符串 
　　例如：#define S(a,b) a*b 
　　area=S(3,2)；第一步被换为area=a*b; ，第二步被换为area=3*2; 
　　类似于函数调用，有一个哑实结合的过程： 
　　（1）实参如果是表达式容易出问题 
　　#define S(r) r*r 
　　area=S(a+b);第一步换为area=r*r;,第二步被换为area=a+b*a+b; 
　　正确的宏定义是#define S(r) ((r)*(r)) 
　　（2）宏名和参数的括号间不能有空格 
　　（3）宏替换只作替换，不做计算，不做表达式求解 
　　（4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内存 
　　（5）宏的哑实结合不存在类型，也没有类型转换。 
　　（6）函数只有一个返回值，利用宏则可以设法得到多个值 
　　（7）宏展开使源程序变长，函数调用不会 
　　（8）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、值传递、返回值）