C语言--预处理详解---#define的用法及注意事项

预定义符号

形如：

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

这些都叫做C语言中的预定义符号，它们各自代表着含义。下面我们来打印一下观察它们的内容。

#include 
int main()
{
	printf("%s\n", __FILE__);//当前文件的路径
	printf("%d\n", __LINE__);//当前代码的行号
	printf("%s\n", __DATE__);//系统当前日期
	printf("%s\n", __TIME__);//系统当前时间
	printf("%s\n", __FUNCTION__);//当前代码所在函数
	return 0;
}

打印结果：

那么这些预定义符号有什么用呢？其实我们在以后编写代码的时候，可能遇到的代码很长，而且会出现一些问题，为了保证我们能及时发现问题在哪里，我们可以使用这些预定义符号来在运行时打印出我们的运行日志输出到日志文件里，这样，当代码出现了问题，我们可以根据日志信息来查找出问题的地方。

---

#define

#define 是我们的老朋友了，今天让我们对他一探究竟。

#define定义标识符

//语法：
 #define name stuff

它的意思就是：将stuff这个东西取了个新名字name，以后可以直接使用name来替换stuff。这个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__ )

这里我们可能会想到这样一个问题：使用#define定义标识符需不需要在结尾加上;呢？

我们的答案是：不加！

因为我们知道#define其实就是简单机械的完全替换，所以加上分号有可能会发生错误，所以最好不加！

//加上;号出错的伪代码
#define A 1000;
...
if(true)
	int a = A;
else int b = A;
...

事实上，else会报错。因为#define是完全替换，所以其实int a = A;实际上是int a = 1000;;这里会有两个分号，第二个;会被识别成一个单独的空语句。而if没有加大括号，所以else会报错。

---

#define定义宏

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

宏的定义方式：

#define name( parament-list ) stuff

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

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

下面我们根据几个例子来体验宏定义的使用以及注意事项：

1. 观察下面代码，体验宏的使用：

#define MUL(X, Y) X*Y

int main()
{
	int a = 5;
	int b = 8;
	int ret = MUL(a, b);
	printf("%d\n", ret);
	return 0;
}

这段代码中，宏的替换是这样的：
原：int ret = MUL(a,b);
宏替换：int ret = a*b;
所以这里打印的结果是40。

2. 观察下面代码，看看结果是否出乎意料：

#define MUL(X, Y) X*Y

int main()
{
	int a = 5;
	int b = 8;
	int ret = MUL(a + 2, b + 1);
	printf("%d\n", ret);
	return 0;
}

可能大家会以为这段代码的打印结果是：63
但是实际上，这段代码的结果是：22
为什么呢？
我们说过，#define宏定义只是简单机械的替换！
所以，这段代码中宏的替换是这样的：
原：ret = MUL(a + 2, b + 1)
宏替换：ret = a + 2 * b + 1 = 5 + 2 * 8 + 1 = 22

为了避免上述问题，我们在定义宏时，应该给每个参数都带上括号！即将上述代码中的定义宏修改为：
#define MUL(X, Y) (X)*(Y)

3. 然而给参数加上括号就万事大吉了吗？我们来看下面的代码：

#define ADD(X, Y) (X)+(Y)

int main()
{
	int a = 5;
	int b = 8;
	int ret = 10 * ADD(a, b);
	printf("%d\n", ret);
	return 0;
}

我们很可能会以为上面打印的结果会是：130
但是实际上打印的结果是：58
实际上这段代码中宏是这样工作的：
原：ret = 10 * ADD(a, b);
宏替换后：ret = 10 * (a) + (b) = 10*5+8 = 58

为了避免这个问题，我们除了给宏的参数加上括号，还要给整个宏定义的部分加上括号，也就是：
#define ADD(X, Y) ((X)+(Y))

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

---

#define 替换规则

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

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

例如：
#define M 100
#define ADD(X) ((X) * (X))
…
int ret = ADD(12 , M);
…
就是首先对ADD参数进行检查，然后将M替换成100。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值替换。也就是我们说的，这一步将源代码用宏简单机械的替换掉！
3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

注意：

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

就是比如：
#define M 100
printf("M = %d",M);
printf函数中“”之间的那个字符串中的M是不会被搜索替换的。

---

# 和 ##

#和##都是在宏定义时，在stuff部分使用的符号。
关于#和##这是两个很有意思的设定，在我们了解他们之前，先来看一段代码：

int main()
{
	char* ch = "hello"" world" "\n";
	printf("%s", ch);
	printf("hello world\n");
	printf("hello ""world\n");
	
	return 0;
}

上面三个打印的结果是一样的吗？

是的，是一样的。
所以我们可以知道，在C语言中，几个被用“”分开的字符串，其实会在编译时将他们合起来。
"hello world" == "hello"" world"

---

当知道了这个我们再来介绍#这个符号的意义。

#：将一个宏参数转化为一个字符串。

这是什么意思呢？来看一段代码：

#define PRINT(A,FORMAT) printf("变量 "#A" 的值是：" FORMAT "\n",A)

int main()
{
	float myVal = 88.88;
	PRINT(myVal, "%.2f");
	return 0;
}

打印结果：

可以看到，#这个符号，在宏定义中是这样使用的：#A，这个A是宏中的一个参数，而在实际运行中#A被理解成为一个字符串，这个字符串，就是在调用宏时传入的那个参数的名字myVal。

同时我们可以观察到，在宏中同样可以将字符串宏定义一个名字，比如上面代码中，FORMAT这个参数在传参时我们传入了一个格式化用的字符串“%.2f”

所以，上面的宏在编译时其实是被替换成了这样的代码：

//宏：
printf("变量 "#A" 的值是：" FORMAT "\n",A)
//替换后：
printf("变量 ""myVal"" 的值是：" "%.2f" "\n",myVal)
//再进一步将字符串都合起来：
printf("变量 myVal 的值是：%.2f\n",myVal)

---

那么##又是什么意思呢？

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

来看例子：

#define TEST(A,B) A##B

int main()
{
	char zhangsan[100] = "张三";
	printf("打印结果：%s\n", TEST(zhang, san));
}

这段代码会报错吗？能有输出结果吗？

很神奇吧。
其实这段代码中的宏的替换是这样的：

//原：
printf("打印结果：%s\n", TEST(zhang, san));
//替换后：
printf("打印结果：%s\n", zhangsan);

也就是说，##符号硬生生将两个参数合起来了，哪怕这个参数是标识符。

---

带副作用的宏参数

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

例如：

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

我们看下面代码，来理解带有副作用的宏参数：

#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++/y++都带有副作用，会改变自身的值，最后的输出的结果是：x=6 y=10 z=9

所以，如果我们在宏中使用了带有副作用的语句，很可能因为宏中多次调用参数，对一些变量的值造成不可预料的后果。因此在宏定义中应该避免使用这种类似于++的带有副作用的语句！

---

宏和函数对比

宏通常被应用于执行简单的运算，而函数用于实现那些比较复杂的逻辑运算和功能。

比如计算两个数的大小：

#define MAX(a, b) ((a)>(b)?(a):(b))

当然我们完全可以使用函数完成相同的功能，但是就此而言，我们会选择使用宏定义来完成这个功能。那么宏有何优势呢？

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

我们举个例子来看看宏定义无关类型的优势：

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

可以看到，如果我们不使用宏，那么我们使用malloc时必须每次都指定类型，修改类型大小。但是使用宏定义后，具体的开辟我们无需关心类型，只需要在MALLOC中传入参数即可，方便很多。

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

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

通过下表了解宏定义和函数的区别：

---

#undef

该指令用于移除一个宏定义！

举例：

#define M 100

int main()
{
	int a = M;

#undef M

	int b = M;
}

可以看到，当移除对M的宏定义后，后面再使用M就会出错！