企业官网建设流程全解析

C 语言预处理详解：预定义符号、宏定义、条件编译与头文件包含

1. 预定义符号

C 语言内置了一些预定义符号，可以直接使用，它们同样在预处理期间就被处理掉：

__FILE__// 进行编译的源文件__LINE__// 文件当前的行号__DATE__// 文件被编译的日期__TIME__// 文件被编译的时间__STDC__// 如果编译器遵循 ANSI C，其值为 1，否则未定义

使用示例：

printf("file:%s line:%d\n",__FILE__,__LINE__);

2. #define 定义常量

基本语法：

#definenamestuff

举个例子：

#defineMAX1000#defineregregister// 为 register 这个关键字创建一个简短的名字#definedo_foreverfor(;;)// 用更形象的符号来替换一种实现#defineCASEbreak;case// 写 case 语句时自动把 break 写上

如果定义的 stuff 过长，可以分成几行写，除最后一行外，每行末尾都要加一个反斜杠\（续行符）：

#defineDEBUG_PRINTprintf("file:%s\tline:%d\t \ date:%s\ttime:%s\n",\__FILE__,__LINE__,\__DATE__,__TIME__)

定义标识符时不要在最后加分号。比如写成#define MAX 1000;，那么在下面这段代码里：

if(condition)max=MAX;elsemax=0;

替换之后 if 和 else 之间就变成了两条语句，而没有大括号时 if 后面只能有一条语句，于是出现语法错误。

3. #define 定义宏

#define机制允许把参数替换到文本中，这种实现通常称为宏（macro）。声明方式：

#definename(parament-list)stuff

parament-list是一个由逗号隔开的符号表，它们可能出现在 stuff 中。

注意：参数列表的左括号必须与 name 紧邻。如果两者之间有任何空白，参数列表就会被解释为 stuff 的一部分。

举个例子：

#defineSQUARE(x)x*x

这个宏接收一个参数 x。之后把SQUARE( 5 );置于程序中，预处理器就会用5 * 5替换它。但观察下面这段代码：

inta=5;printf("%d\n",SQUARE(a+1));

乍一看应该打印 36，实际上打印的是 11。替换文本时参数 x 被替换成a + 1，这条语句实际变成了：

printf("%d\n",a+1*a+1);

由替换产生的表达式没有按照预想的次序求值。给参数加上括号就能解决：

#defineSQUARE(x)(x)*(x)

替换之后就产生了预期效果：

printf("%d\n",(a+1)*(a+1));

但只给参数加括号还不够，看另一个宏：

#defineDOUBLE(x)(x)+(x)

inta=5;printf("%d\n",10*DOUBLE(a));

看上去好像打印 100，事实上打印的是 55，因为替换之后是：

printf("%d\n",10*(5)+(5));

乘法运算先于宏定义里的加法，所以出现了 55。解决办法是在宏定义表达式两边再加一对括号：

#defineDOUBLE(x)((x)+(x))

所以，用于对数值表达式求值的宏定义都应该按这种方式加括号，避免在使用宏时，参数中的操作符和邻近操作符之间发生不可预料的相互作用。

4. 带有副作用的宏参数

当宏参数在宏的定义中出现超过一次的时候，如果参数带有副作用，使用这个宏就可能出现危险，导致不可预测的后果。副作用就是表达式求值时出现的永久性效果：

x+1;// 不带副作用x++;// 带有副作用

MAX宏可以说明带有副作用的参数所引起的问题：

#defineMAX(a,b)((a)>(b)?(a):(b))...x=5;y=8;z=MAX(x++,y++);printf("x=%d y=%d z=%d\n",x,y,z);

预处理器处理之后的结果是：

z=((x++)>(y++)?(x++):(y++));

x++与y++比较时分别取出 5 和 8，比较结果为假，于是执行条件表达式第三个分支的y++，取出 9 并让 y 变成 10。所以输出结果是x=6 y=10 z=9。

5. 宏替换的规则

在程序中扩展#define定义的符号和宏时，需要涉及几个步骤：

1. 调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替换。
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

有两点需要注意：

• 宏参数和#define定义中可以出现其他#define定义的符号，但是对于宏，不能出现递归。
• 当预处理器搜索#define定义的符号时，字符串常量的内容并不被搜索。

6. 宏和函数的对比

宏通常被应用于执行简单的运算，比如在两个数中找出较大的一个——就是第 4 节的MAX宏。宏和函数各有优劣，完整对比如下：

宏有时候还能做函数做不到的事情：宏的参数可以出现类型。

#defineMALLOC(num,type)\(type*)malloc(num*sizeof(type))// 使用MALLOC(10,int);// 预处理器替换之后：(int*)malloc(10*sizeof(int));

7. # 和

7.1 # 运算符

#运算符将宏的一个参数转换为字符串字面量，它仅允许出现在带参数的宏的替换列表中。#运算符所执行的操作可以理解为「字符串化」。

当有一个变量int a = 10;的时候，我们想打印出the value of a is 10，就可以写：

#definePRINT(n)printf("the value of "#n" is %d",n);

按下面的方式调用PRINT(a);时，a 替换到宏的体内就出现了#a，而#a就是转换为"a"的一个字符串。代码会被预处理为：

printf("the value of ""a"" is %d",a);

相邻的字符串字面量拼接起来，运行代码就能在屏幕上打印：

the value of a is 10

7.2 ## 运算符

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符，因此被称为记号粘合。这样的连接必须产生一个合法的标识符，否则其结果就是未定义的。

这里想一个场景：写一个求两个数较大值的函数时，不同的数据类型就得写不同的函数。

intint_max(intx,inty){returnx>y?x:y;}floatfloat_max(floatx,floaty){returnx>y?x:y;}

这样写起来太繁琐，改用宏来生成：

// 宏定义#defineGENERIC_MAX(type)\type type##_max(type x,type y)\{\return(x>y?x:y);\}

#include<stdio.h>GENERIC_MAX(int)// 替换到宏体内后 int##_max 生成新的符号 int_max 做函数名GENERIC_MAX(float)// 替换到宏体内后 float##_max 生成新的符号 float_max 做函数名intmain(){// 调用函数intm=int_max(2,3);printf("%d\n",m);floatfm=float_max(3.5f,4.5f);printf("%f\n",fm);return0;}

输出：

3 4.500000

在实际开发过程中##使用的很少，很难取出非常贴切的例子。

8. 命名约定

一般来讲函数和宏的使用语法很相似，语言本身没法帮我们区分二者，所以平时的习惯是：把宏名全部大写，函数名不要全部大写。

9. #undef

这条指令用于移除一个宏定义：

#undefNAME

如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。

10. 命令行定义

许多 C 编译器提供了一种能力，允许在命令行中定义符号，用于启动编译过程。比如根据同一个源文件要编译出一个程序的不同版本时，这个特性就有点用处——假定某个程序中声明了一个某个长度的数组，内存有限的机器需要一个小数组，内存大些的机器则需要数组能够大些。

#include<stdio.h>intmain(){intarray[ARRAY_SIZE];inti=0;for(i=0;i<ARRAY_SIZE;i++){array[i]=i;}for(i=0;i<ARRAY_SIZE;i++){printf("%d ",array[i]);}printf("\n");return0;}

编译指令（Linux 环境下演示）：

gcc-DARRAY_SIZE=10program.c

-D在编译命令上定义了ARRAY_SIZE，源文件里就不必再写对应的#define。

11. 条件编译

在编译一个程序的时候，如果想把一条语句（一组语句）编译进去或者放弃掉，用条件编译指令很方便。比如调试性的代码，删除可惜，保留又碍事，就可以选择性地编译。

#include<stdio.h>#define__DEBUG__intmain(){inti=0;intarr[10]={0};for(i=0;i<10;i++){arr[i]=i;#ifdef__DEBUG__printf("%d\n",arr[i]);// 为了观察数组是否赋值成功#endif//__DEBUG__}return0;}

常见的条件编译指令有以下几类。

单分支，常量表达式由预处理器求值：

#if常量表达式// ...#endif

#define__DEBUG__1#if__DEBUG__// ...#endif

多个分支：

#if常量表达式// ...#elif常量表达式// ...#else// ...#endif

判断是否被定义：

#ifdefined(symbol)#ifdefsymbol#if!defined(symbol)#ifndefsymbol

嵌套指令：

#ifdefined(OS_UNIX)#ifdefOPTION1unix_version_option1();#endif#ifdefOPTION2unix_version_option2();#endif#elifdefined(OS_MSDOS)#ifdefOPTION2msdos_version_option2();#endif#endif

12. 头文件的包含

12.1 头文件被包含的方式

12.1.1 本地文件包含

#include"filename"

查找策略：先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件一样在标准位置查找，如果找不到就提示编译错误。

标准头文件的路径随环境而变，Linux 环境下是/usr/include，VS 环境下类似C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include（这是 VS2013 的默认路径），实际要按自己的安装路径去找。

12.1.2 库文件包含

#include<filename.h>

查找头文件时直接去标准路径下去查找，如果找不到就提示编译错误。

那么对于库文件是不是也可以使用""的形式包含？答案是肯定的，可以，但是这样做查找的效率就低些，而且不容易区分是库文件还是本地文件了。

12.2 嵌套文件包含

#include指令可以使另外一个文件被编译，就像它实际出现于#include指令的地方一样。这种替换方式很简单：预处理器先删除这条指令，并用包含文件的内容替换。

一个头文件被包含 10 次，那就实际被编译 10 次，如果重复包含，对编译的压力就比较大。比如：

test.c：

#include"test.h"#include"test.h"#include"test.h"#include"test.h"#include"test.h"intmain(){return0;}

test.h：

voidtest();structStu{intid;charname[20];};

这样 test.c 文件中将 test.h 包含 5 次，test.h 文件的内容会被拷贝 5 份到 test.c 中。如果 test.h 文件比较大，预处理后代码量会剧增；工程一大，有被大家公共使用的头文件又不做任何处理，后果不堪设想。

解决办法是条件编译，每个头文件的开头写：

#ifndef__TEST_H__#define__TEST_H__// 头文件的内容#endif//__TEST_H__

或者：

#pragmaonce

都可以避免头文件的重复引入。

13. 其他预处理指令

#error#pragma#line...

这些指令用到时再自行了解即可，其中#pragma pack()在结构体部分介绍。想深入的话可以参考《C 语言深度解剖》。