完全自学C(干货) —— 预处理详解_源码的预处理操作-优快云博客

本文链接：https://blog.youkuaiyun.com/NapoleonCoder/article/details/129969099

文章详细介绍了C语言中的预处理指令，包括预定义符号如__FILE__和__LINE__，#define用于宏定义，无参数和带参数的宏，以及#和##的用法。还讨论了带副作用的宏参数、宏与函数的对比、命令行定义、条件编译、文件包含（头文件包含）以及其他预处理指令的应用。这些内容对于理解和编写C程序至关重要。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

以“#”开头的均为预处理指令；
预处理是在编译前对源码的文本操作；

一，预定义符号

C语言已预先定义好的内置符号（预定义宏）；
可用于日志信息，以便于调试等；

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

int main()
{
	printf("%s\n", __FILE__); //F:\VS\Project1\test.c
	printf("%d\n", __LINE__); //1990
	printf("%s\n", __DATE__); //Aug  1 2021
	printf("%s\n", __TIME__); //10:23 : 43
}

二，#define

可分为无参数宏定义和带参数宏定义；
标识符习惯全部大写，以区分变量名；

#define定义的标识符

#define name stuff

预处理阶段时，替换；
末尾建议不要加(;)，否则多一个空语句或语法错误；
也可称为无参宏定义；

#define MAX 1000 //可替换数值
#define reg register //可替换关键字
#define do forever for(;;) //可替换一段语句
#define CASE break;case //可替换一段代码
//可替换多行代码（\续行符）
#define DEBUG_PRINT printf("file:%s\tline:%d\tdate:%s\ttime:%s\n",\
							__FILE__, __LINE__, \
							__DATE__, __TIME__)

#define定义宏

允许把参数替换到文本中，称为宏（macro）或定义宏（define macro）；

#define name( parament-list ) stuff

parament-list 参数列表，会在stuff中完成替换；
括号（）必须紧邻name；
也可称为带参宏定义；

#define SQUARE(x) x*x
int main()
{
	int ret = SQUARE(4); //先传参，在替换
	printf("%d", ret); 
}
//结果：16

注：

宏是先替换，在计算的；
对数值表达式进行求值的宏定义，应加上括号，避免在使用宏时由于参数中的操作符和邻近操作符之间产生歧义；

#define SQUARE(x) x*x
int main()
{
	int ret1 = SQUARE(3 + 1); //3+1*3+1
	int ret2 = 3 * SQUARE(3 + 1); //3*3+1*3+1
	printf("%d %d", ret1, ret2);
}
//结果：7 13

#define SQUARE(x) ((x)*(x))
int main()
{
	int ret1 = SQUARE(3 + 1); //(3+1)*(3+1)
	int ret2 = 3 * SQUARE(3 + 1); //3*((3+1)*(3+1))
	printf("%d %d", ret1, ret2);
}
//结果：16 48

#define替换规则

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

#define M 100
#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
	int ret = MAX(10, M);
	return 0;
}

注：

宏参数，在#define定义中，可以出现其他#define定义的变量；
宏可嵌套，不可递归（即不能替换自己）；
当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索；

#define M 100
//#define N 100 + M ，可嵌套
//#define N 100 + N ，不可递归
int main()
{
	printf("M"); //此M不会被替换
	return 0;
}

# 和 ##

#

#宏参数，可把一个宏参数变成对应的字符串；
可实现在字符串中插入参数；

#define fun(x) #x //即转换为“x”
int main()
{
	char str[] = fun(abcd);
	printf("%s", str);
	return 0;
}
//结果：abcd

#define print(x, Format) printf("The value of " #x " " Format "!\n", x)
int main()
{
	int num1 = 10;
	float num2 = 20;
	print(num1, "%d"); //printf("The value of ""num1"" %d!\n", num1)
	print(num2, "%f"); //printf("The value of ""num2"" %f!\n", num2)
	return 0;
}
//The value of num1 10!
//The value of num2 20.000000!

##

可把两边的符号合成一个符号；
连接后需产生一个合法的标识符；

#define CAT(x, y) x##y
int main()
{
	char str[] = "ab""cd";//int num2 = "ab""cd",即"abcd";
	int num1 = 10;
	int num2 = CAT(num, 1); //int num2 = num1;
	return 0;
}

带副作用的宏参数

当宏参数在宏定义中出现超过一次时，带有副作用的参数，可能会出现未知风险；
副作用即表达式求值时出现的遗留性效果；

#define MAX(x, y) ((x)>(y)?(x):(y))

int main()
{
	int a = 5;
	int b = 8;
	int ret = MAX(a++, b++); //((a++)>(b++)?(a++):(b++))
	printf("%d %d %d", ret, a, b); //9 6 10
}

宏和函数的对比

宏，通常被用于执行简单的运算；

宏优势

用于调用函数和函数返回的代码，可能会比实际执行小型计算的工作量所需时间更多；所以宏比函数在程序的规模和速度方面更优；
函数的参数必须声明为特定的类型，所以函数只能在类型合适的表达式上使用；但宏与类型无关；

宏劣势

每次使用宏时，会插入到程序中；可能会大幅度增加程序的长度；
宏无法调试，调试是在可执行程序后；
宏与类型无关，所以不够严谨；
宏可能带来运算符优先级的问题，容易出错；

//宏，可传类型参数
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main()
{
    //(int*)malloc(10*sizeof(int))
	MALLOC(10, int);
    return 0;
}

注：命名约定，宏名全部大写，函数名不全部大写；

#undef

#undef name

取消宏定义

#define M 100

int main()
{
	#undef M
	printf("%d", M); //M为未定义的标识符
	return 0;
}