预处理在编译器读语法之前运行。它看到的是记号序列,不知道 int 是类型,也不知道 if 后面该跟什么。它的工作只有几类:展开宏(macro)、处理条件编译(conditional compilation)、把 #include 的文件插进来、删注释、记行号。
预定义符号:编译器替你写好的值
C 语言预置了几个符号,在预处理阶段直接展开:
__FILE__:当前源文件名,字符串字面量。__LINE__:当前行号,整数。__DATE__:文件被编译的日期,字符串。__TIME__:文件被编译的时间,字符串。__STDC__:编译器遵循 ANSI C 时为 1,否则未定义。
#include <stdio.h>
int main(void)
{
printf("file:%s line:%d\n", __FILE__, __LINE__);
return 0;
}它们也是宏。__LINE__ 在宏体里出现时,展开成调用这个宏的那一行,不是 #define 所在的行;__DATE__ 的格式是 Mmm dd yyyy,__TIME__ 是 hh:mm:ss,两者都是编译那一刻的值,程序放一年再跑也不会变。
#define 定义常量:末尾不要分号
#define name stuff 把 name 替换成 stuff,替换发生在记号层面。宏名会换掉源码里所有同名记号,变量名、函数名撞上也会被换掉,取名要够独特。
#define MAX 1000
#define reg register
#define do_forever for(;;)
#define CASE break; casereg 只是给 register 换个短名字,do_forever 把 for(;;) 包装成一个短语,CASE 让写 case 时自动带上 break;。它们都只是文本替换,不引入类型,也不做作用域检查。
stuff 太长可以分行,除最后一行外每行末尾写反斜杠作续行符:
#define DEBUG_PRINT printf("file:%s\tline:%d\tdate:%s\ttime:%s\n", \
__FILE__, __LINE__, __DATE__, __TIME__)反斜杠必须是那一行的最后一个字符;后面多一个空格,续行就断了。
末尾不要写分号。#define MAX 1000; 在 n = MAX; 里变成 n = 1000;;,单独一行没事;放进不带大括号的 if:
#define MAX 1000; /* 反例:末尾多了分号 */
int pick(int condition)
{
int max;
if (condition)
max = MAX;
else
max = 0;
return max;
}max = MAX; 展开成 max = 1000;;,if 和 else 之间多出一条空语句,else 找不到自己的 if,语法错误;把宏定义末尾的分号去掉就正常。
要撤掉一个宏用 #undef NAME。同一个名字可以重新定义,但两次定义的记号序列必须完全相同,否则实现要给诊断;实际项目里先 #undef 再定义更稳。
带参宏:参数是记号,括号是纪律
#define name(parament-list) stuff 里,参数列表的左括号必须紧贴宏名;中间有空白,整个括号会被当成 stuff 的一部分,宏就变成无参宏。
#define SQUARE(x) x * x
#define DOUBLE(x) (x) + (x)SQUARE(a + 1) 展开成 a + 1 * a + 1,按优先级算是 a + (1 * a) + 1,a 为 5 时得 11,不是 36。10 * DOUBLE(a) 展开成 10 * (5) + (5),得 55,不是 100。
修法是把每个参数出现的位置包起来,再给整个宏体包一层:
#define SQUARE(x) ((x) * (x))
#define DOUBLE(x) ((x) + (x))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))括号解决优先级,解决不了求值次数。参数在宏体里出现几次,实参就展开几次:
#include <stdio.h>
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
int main(void)
{
int x = 5;
int y = 8;
int z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);
return 0;
}展开成 (((x++) > (y++)) ? (x++) : (y++))。比较时 x 从 5 变 6、y 从 8 变 9;比较为假,走 (y++),取出 9、y 变 10。输出 x=6 y=10 z=9。函数不会这样,函数的实参进入函数体前只求值一次。
课件把副作用解释成“表达式求值的时候出现的永久性效果”,这个定义不准。C 标准里的副作用是对执行环境状态的改变:改了一个对象的值、做了一次 I/O、写了一个 volatile 对象,都算。x + 1 没有副作用,x++ 有;判断依据是“有没有改状态”,不是“改得久不久”。
宏替换的顺序,和多语句宏的外壳
宏展开分三步:先检查实参里有没有 #define 定义的符号,有就先展开;再把宏体里的参数名替换成对应的记号;最后重新扫描结果,遇到新的宏继续展开。
有两条边界:# 和 ## 的操作数不会先展开;字符串常量里的内容不会被搜索。宏名在自己的展开过程里也不再展开,所以 #define f(x) f(x) 调用 f(1) 只展开一次,停在 f(1),随后编译器把它当成未声明的函数报错。课件说“宏不能递归”,准确点说,递归宏不会无限展开,它会静默地停住。
文本替换带来的直接后果是多语句宏在 if 里散架:
#include <stdio.h>
#define SWAP(a, b) int tmp = a; a = b; b = tmp;
void reorder(int x, int y)
{
if (x < y)
SWAP(x, y);
else
puts("no");
}展开后只有 int tmp = x; 受 if 管,后两句跑到外面,else 找不到 if。把宏体塞进 do { } while (0),整体在语法上是一条语句:
#define SWAP(a, b) \
do { \
int tmp = (a); \
(a) = (b); \
(b) = tmp; \
} while (0)调用方写 SWAP(x, y);,展开成 do { } while (0);,分号落在 while (0) 后面,正好。宏定义本身末尾仍然不要加分号。
课件的 PRINT 宏在末尾带了分号:
#define PRINT(n) printf("the value of "#n " is %d", n);PRINT(a); 展开成 printf("the value of ""a"" is %d", a);;,和 #define MAX 1000; 是同一个坑。去掉分号即可,#n 的拼接没有问题。
# 和 ##:字符串化与粘名字
# 只能出现在带参宏的替换列表里,作用是把参数对应的记号序列变成字符串字面量:
#include <stdio.h>
#define PRINT(n) printf("the value of " #n " is %d\n", (n))
int main(void)
{
int a = 10;
PRINT(a); /* the value of a is 10 */
return 0;
}参数两侧的空白会被压掉,中间的连续空白合成一个空格;参数里的引号和反斜杠会被转义。参数本身是表达式时,PRINT(a + b) 得到字符串 "a + b"。assert 就是靠它把失败的表达式原样打出来的。
## 把左右两个记号粘成一个新记号:
#define GENERIC_MAX(type) \
type type##_max(type x, type y) \
{ \
return (x > y ? x : y); \
}
GENERIC_MAX(int)
GENERIC_MAX(float)type##_max 在 type 是 int 时粘成 int_max。粘出来的结果必须是一个合法的记号,x ## + 这种标准不给任何保证;## 也不能出现在替换列表的开头或结尾。
# 和 ## 的操作数不会先展开。想先展开再加 ##,垫一层:
#define CAT_IMPL(a, b) a##b
#define CAT(a, b) CAT_IMPL(a, b)
#define N 10
/* CAT(N, 1) 先把 N 展开成 10,再交给 CAT_IMPL 粘成 101 */宏和函数:一张表和三条判据

表里的结论逐条对:宏每次使用都插入一份代码,程序变长;函数只有一份,但有调用和返回开销;宏的参数在周围表达式里求值,优先级要靠括号;宏参数可能被求值多次;宏与类型无关;宏不能逐语句调试;宏不能递归。
宏的参数是记号,函数的参数是值。宏不认识类型,所以同一个 MAX 可以比较 int、double、char;也正因为不认识类型,编译器没法在宏这一层检查参数。宏展开在预处理阶段,函数调用在运行阶段;宏没有栈帧,也没有返回地址。
宏不可替代的地方只有几类。参数可以带类型:
#define MALLOC(num, type) ((type *)malloc((size_t)(num) * sizeof(type)))课件里的 MALLOC 示例展示的就是这个用法;按原意,type 后面要有 *,num 和 sizeof(type) 之间要有 *,整个表达式外面还要再包一层括号。
第二类是让代码在编译期消失,第三类是让 #if 看得见——这两类在下一节。剩下能用函数写的,优先用函数或 static inline:能调试、参数只求值一次、类型检查完整。
命名约定也在这里:宏名全大写,函数名不全大写。语言不区分二者,约定是为了让读代码的人一眼提高警惕。
条件编译与头文件
#if 后面的表达式由预处理器求值,只认整型常量和宏。枚举常量、const 变量、sizeof 都不在它的范围里;表达式里出现的未定义标识符一律当成 0,所以 #if FOO 在 FOO 没定义时就是 #if 0,不报错。拼错一个宏名,分支会安静地失效。
#if 0 是常用的临时屏蔽手段,被包住的代码连语法都不需要正确;用注释包代码,注释不能嵌套,里面再出现一个 /* 就乱了。
#if、#elif、#else、#endif 按常量表达式的值选一段;#ifdef symbol 和 #ifndef symbol 判断某个宏是否存在,defined(symbol) 可以写在 #if 里,取反写 !defined(symbol)。这些指令可以嵌套。
#include <stdio.h>
#define OS_UNIX 1
#define OPTION1 1
int main(void)
{
#if defined(OS_UNIX)
#ifdef OPTION1
puts("unix option1");
#endif
#elif defined(OS_MSDOS)
puts("msdos");
#endif
return 0;
}外层 #if defined(OS_UNIX) 为真时,里面的 #ifdef OPTION1 才会被处理;外层为假时整段跳过,内层指令连参与都不参与。
#include <stdio.h>
int main(void)
{
int arr[10];
for (int i = 0; i < 10; i++)
{
arr[i] = i;
#ifdef DEBUG
printf("%d\n", arr[i]);
#endif
}
return 0;
}定义 DEBUG 时打印,不定义时这一行连同字符串都不进翻译单元;if (DEBUG) 做不到这一点,代码和字符串仍然在,只是可能被优化掉。
命令行也能定义:
gcc -D ARRAY_SIZE=10 program.c-D 与宏名之间有没有空格都接受。课件这条命令写的是 programe.c,文件名多了一个 e,照着敲会找不到文件。同一个源文件想编出不同数组大小的版本,用 -D 在命令行改宏,源码不用动。-U NAME 用来抵消头文件里的默认定义。
#include 有两种写法。#include "filename" 先在源文件所在目录找,找不到再去标准位置;#include <filename> 直接去标准位置。标准位置由实现决定,Linux 通常在 /usr/include,VS 在安装目录下的 VC\include。用 "" 包含系统头文件也能编过,只是多一次本地查找,也看不出这是库文件还是项目文件;反过来,项目里恰好有个同名的本地文件时,<> 不会误用它。
#include 可以递归:被包含的头文件里还能再包含别的文件,直到所有内容都展开完。
这两条也是常见的笔试题:#ifndef/#define/#endif 用来防重复包含;<> 和 "" 的区别在查找起点,"" 多一层“源文件所在目录”。
头文件被重复包含时,#include 是纯文本插入:包含五次,内容就在预处理后的文件里出现五次。课件说“实际被编译 10 次”,准确说是预处理阶段展开 10 次,整个翻译单元最后只编译一次;代价是重复定义报错和代码量增长。
守卫写法:
#ifndef TEST_H
#define TEST_H
void test(void);
struct Stu
{
int id;
char name[20];
};
#endif守卫的宏名通常按文件路径取名,避免两个头文件都叫 TEST_H。#pragma once 也能防重复,按文件身份去重,不是 C 标准的一部分,主流编译器都支持;守卫在旧编译器上也能用,两种写法可以同时留着。
#error 会把后面的消息打出来并终止预处理,适合放在平台分支的 else 里;#line 改掉后续的行号和文件名,影响 __LINE__、__FILE__ 的展开结果;#pragma 的内容由编译器自己解释,#pragma pack 控制结构体对齐。
预处理阶段的所有东西都在语法分析之前定型;宏的坑也全部发生在这一步——括号没加、参数求值两次、末尾多一个分号,编译器看到的已经是错位的记号,报错却落在后面的行上。
还没有评论 — 第一条由你来留。