【C语言】预处理详解

一、预定义符号

预定义符号是指在编程语言中已经被赋予了特定含义的符号或关键字。

 __FILE__ 	//进行编译的源文件
__LINE__ 	//文件当前的行号
__DATE__ 	//文件被编译的日期
__TIME__ 	//文件被编译的时间
__STDC__ 	//如果编译器遵循ANSI C，其值为1，否则未定义
__FUNCTION__//获取当前函数的名称作为一个字符串常量
——FUNCDNAME__//获取当前函数的名称作为一个字符串常量

区别在于，__FUNCTION__返回的函数名可能不包括命名空间或类名，而__FUNCDNAME__返回的函数名是完全限定的。

这些预定义符号都是语言内置的。
例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (i = 0; i < 10; i++)
	{
		printf("%d----%s,%s,%s,line=%d\n",arr[i],__FILE__, __DATE__, __TIME__, __LINE__);
	}
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	printf("%s\n%s", __FUNCTION__, __FUNCDNAME__);
	return 0;
}

二、#define

2.1 定义标识符

语法：

#define name stuff

例：

#define MAX 1000
#define reg register //为 register这个关键字，创建一个简短的名字
#define do_forever for(;;) //用更形象的符号来替换一种实现
#define CASE break;case //在写case语句的时候自动把 break写上。
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
date:%s\ttime:%s\n" ,\
__FILE__,__LINE__ , \
__DATE__,__TIME__ )

本质上就是在预处理阶段¹进行替换。

如图所示：

2.2 定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。

宏的申明方式：

#define name( parament-list ) stuff

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

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

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#define SQUARE(x) x*x//定义一个求平方的宏
int main()
{
	printf("%d", SQUARE(8));
	return 0;
}

但是这个宏存在一个问题：

#include <stdio.h>
#define SQUARE(x) x*x//定义一个求平方的宏
int main()
{
	printf("%d", SQUARE(1+4));
	return 0;
}

上面这段代码，看起来结果输出25，但实际上输出9，前面说过#define是在预处理阶段进行替换，所以这段代码被替换后是这样的：

怎么解决呢？在宏定义的两边加上括号就解决了：

#define SQUARE(x) (x)*(x)
//这样替换后便是
printf("%d",(1+4)*(1+4));

但还有一个缺陷，比如下面这个宏定义：

#define  DOUBLE(x) (x)+(x)

定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误。

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

它在这段代码中替换后是这样的：

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

结果本该是100，但这里却是55。
为避免这个问题，我们在宏定义表达式两边再加上一对括号：

#define  DOUBLE(x) ((x)+(x))//这样就可以了

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

2.3 #define定义规则

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

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

注意：

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

2.4 #和##

#操作符用于将宏参数转换为字符串常量
##操作符用于将两个标记合并为一个标记

2.4.1 #的作用

首先我们看看这样的代码：

char* p = "hello ""world\n";
printf("hello"" world\n");
printf("%s", p);

这里输出的是hello world，因为字符串是有自动连接的特点的。

那我们就可以写这样的代码：

#define PRINT(FORMAT, VALUE)\
printf("the value is "FORMAT"\n", VALUE);
...
PRINT("%d", 10);

这样我们就可以用宏打印不同类型的参数了。
另外一个技巧是：
使用#，把一个宏参数变成对应的字符串
例：

int i = 10;
#define PRINT(FORMAT, VALUE)\
printf("the value of " #VALUE " is "FORMAT "\n", VALUE);
...
PRINT("%d", i+3);

替换过后就成了一个字符串：

2.4.2 ##的作用

##可以把位于它两边的符号合成一个符号。
它允许宏定义从分离的文本片段创建标识符。

举个例子：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#define CAT(x,y) x##y
int main()
{
	int Hello123 = 2023;
	printf("%d", CAT(Hello, 123));
	return 0;
}

这里将Hello和123合成了Hello123,替换后：

结果：

注：
这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。

2.5 带副作用的宏参数

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

例如：

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

MAX宏可以证明具有副作用的参数所引起的问题

#define MAX(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=6 y=10 z=9

2.6 宏和函数对比

• 宏的优点：

1. 函数用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多，所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使用。反之，宏适用于整形、长整型、浮点型等可以用于 > 来比较的类型。
   宏是类型无关的。
   宏的参数可以出现类型，但是函数做不到。

例如：

#define MALLOC(num, type)\
(type *)malloc(num * sizeof(type))
...
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));

• 宏的缺点：

当然和函数相比宏也有劣势的地方：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
2. 宏是没法调试的。
3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

宏和函数的对比：

属性	#define定义宏	函数
代码长度	每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长	函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度	更快	存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级	宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多加括号	函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测
带有副作用的参数	参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果	函数参数只在传参的时候求值一次，结果更容易控制
参数类型	宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型	函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是相同的
调试	宏是不方便调试	函数是可以逐语句调试的
递归	宏是不能递归的	函数是可以递归的

2.7 命名约定

一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区分二者。
那我们平时的一个习惯是：

• 把宏名全部大写
• 函数名不要全部大写

三、#undef

#undef是一个预处理指令，用于取消宏定义

• #undef指令通常用于在同一程序中重新定义宏，或者在使用某个库之前取消宏定义，以确保不会与库中的宏定义冲突。

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

例如：

#define M 100
int main()
{
	printf("%d\n", M);
#undef M
	printf("%d\n", M);
	return 0;
}

四、命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）

例如：

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

我们使用命令行定义ARRAT_SIZE

编译指令：

//linux 环境演示
gcc -D ARRAY_SIZE=10 programe.c

五、条件编译

条件编译是一种在编译时根据条件选择性地包含或排除代码的技术。
也就是可以选择编译或者不编译。

#endif是条件编译指令的一部分，用于结束一个条件编译块。

以下是几种常见的条件编译指令：

• #ifdef和#ifndef：这两个指令用于检查一个宏是否已经定义。

#ifdef指令用于检查宏是否已经定义，如果已经定义，则编译指定的代码块。也可以用#if defined()
#ifndef指令则相反，如果宏没有定义，则编译指定的代码块。也可以用if !defined()

例如，调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译：

#include <stdio.h>
#define __DEBUG__
int main()
	{
	int i = 0;
	int arr[10] = {0};
	for(i=0; i<10; i++)
	{
		arr[i] = i;
		#ifdef __DEBUG__//#if defined(__DEBUG__)
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
		#endif //__DEBUG__
	}
	return 0;
}

• #if、#elif和#else：这两个指令用于根据条件编译指定的代码块。

#if指令接受一个常量表达式作为参数，并根据表达式的结果来决定是否编译指定的代码块。表达式为真则参与编译，假则不参与编译。
#elif则用于在多个条件之间进行选择。
#else则用于指定所有条件都不满足时要执行的代码块。

模板：

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

例：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#define A 100
int main()
{
#if A==1
	printf("a=1");
#elif A
	printf("A=%d",A);
#else
	printf("other");
#endif
	return 0;
}
//结果输出A=100

注意：

常量表达式不能是变量，因为变量在运行起来后才创建，而预处理指令在预处理阶段就创建了。
例如，这样写是错误的：

因为a是一个变量，而不是一个常量。因此，编译器无法在编译时计算a的值，而会将a视为未定义的符号。
在C/C 中，条件编译指令是在编译时处理的，而不是在运行时处理的。这意味着编译器会根据条件编译指令中的条件表达式来决定哪些代码应该被编译，哪些代码应该被忽略。在条件编译指令中，条件表达式必须是一个常量表达式，这意味着它必须在编译时就能够计算出结果。

• 嵌套指令
  例：

#if defined(OS_UNIX)
	#ifdef OPTION1
		unix_version_option1();
	#endif
	#ifdef OPTION2
		unix_version_option2();
	#endif
#elif defined(OS_MSDOS)
	#ifdef OPTION2
		msdos_version_option2();
	#endif
#endif

六、文件包含

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

6.1 头文件被包含的方式

• 本地文件包含

#include "filename"

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

Linux环境的标准头文件的路径：

/usr/include

VS环境的标准头文件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include

注意按照自己的安装路径去找。

• 库文件包含

#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。 这样是不是可以说，对于库文件也可以使用" "的形式包含？
答案是肯定的，可以。 但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。
所以库文件最好用< >的形式包含。

6.2 嵌套文件包含

如果出现这样的场景：

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。

这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。
使用条件编译便能解决这个问题。
每个头文件的开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__

或者：

#pragma once

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

七、其他预处理指令

• #error
  它用于在编译时生成一个错误消息。当编译器遇到 #error 指令时，它将停止编译并显示指定的错误消息。
• #pragma
  用于向编译器发出指令或提示。#pragma 指令通常用于控制编译器的行为，例如设置编译器选项、指定库文件、定义宏等。
  以下是一些常见的 #pragma 指令：

#pragma once：指示编译器只包含一次头文件。
#pragma warning：用于控制编译器的警告信息。
#pragma pack：用于控制结构体成员的对齐方式。
#pragma message：用于在编译时输出一条消息。
#pragma optimize：用于控制编译器的优化级别。
#pragma comment：用于指定链接器需要的库文件或命令行选项。

• #line
  用于指定源代码文件中的行号和文件名。#line 指令通常用于调试和错误报告，可以在编译时更改当前的行号和文件名。
  #line 指令的语法格式如下：

#line [line-number] ["filename"]

其中，line-number 是一个整数，表示当前行号；filename 是一个字符串，表示当前文件名。

以下是一个示例，使用 #line 指令来指定当前的行号和文件名：

#line 10 "myfile.c"
int main() {
    printf("Hello, world!");
    return 0;
}

在这个例子中，#line 10 "myfile.c" 指令告诉编译器将当前的行号设置为10，文件名设置为 “myfile.c”。因此，在编译时，如果出现错误或警告，编译器将显示当前行号和文件名，以便更容易地调试和定位问题。

本篇完

---

1. 详解见：C语言程序环境 ↩︎