【C语言】#define宏与函数的优劣对比

1. 预处理指令#define宏

#define除了能定义标识符常量外，还允许把参数替换到文本中，这种实现通常称为宏（macro）或定义宏（define macro）。

下面是宏的申明方式：

#define name(parament-list) statement

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

例如实现一个宏，求两个数中的最大值：

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

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

如：

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

MAX后面加了一个空格，这样写的话是没法使用的，(x, y)会被误认为是表达式而不是宏的参数。

2. #define定义标识符或宏，要不要最后加上分号？

比如：

#define PI 3.14;
#define MAX(x, y) ((x) > (y) ? (x) : (y));

建议不要加上分号，这样容易导致问题，比如下面的场景：

int max;
int a = 10;
int b = 20;
if(condition)
	max = MAX(a, b); // error
else
	max = 0;

我们都知道#define在预编译后就会完成符号的替换，在代码中所有出现过#define定义的标识符或宏，都会被替换成所代表的常量或宏参数。

那么上面这么写的话，实际上就变成了这样：

int max;
int a = 10;
int b = 20;
if(condition)
	max = MAX((a) > (b) ? (a) : (b));;
else
	max = 0;

那么后面会有两个分号，一个分号是#define后面带上的，另一个是编码习惯性地带上一个分号。

最关键的是这样替换后的代码，在你实际编写的.c源文件中是看不到的，所以在你的眼中代码任然长这样：

int max;
int a = 10;
int b = 20;
if(condition)
	max = MAX(a, b); 
else
	max = 0;

这样甚至都不需要去编译运行，IDE就能早早发现错误给你报错了，if后没接大括号只能有一条语句，而实际上宏参数被替换后多了个分号，这个分号虽然没有实际的意义，但它也是一条语句。

3.宏的参数替换后产生的运算符优先级问题

3.1 问题产生

如果你写了一个这样的宏，求一个数的平方：

#define SQUARE(n) n * n

然后使用这个宏：

int ret = SQUARE(4);
printf("%d", ret);

咋一看肯定没毛病，能得出正确的结果：

但如果这么使用：

int ret = SQUARE(4 + 1);
printf("%d", ret);

这时你心里想结果是25，实际运行后的结果却是：

为啥呢？其实表达式预编译后长这样：

int ret = 4 + 1 * 4 + 1;
printf("%d", ret);

#define完成的是符号的替换，无论是定义的标识符常量还是宏，要么就是把标识符替换成常量，要么就是将宏表达式的参数替换成你传入的参数。仅仅只是替换工作，并不会帮你计算好再传参，要知道计算的工作是真正在程序运行后才能执行的，预编译阶段才仅仅是编译的第一个阶段呢！文章：.c源文件从编译到链接生成可执行程序的过程

3.2 不太完美的解决办法

解决的办法就是在宏体表达式中，给每个参数加上括号：

#define SQUARE(n) (n) * (n)

这样就确实能得到正确的结果：

3.3 完美的解决办法

但实际上像上面这样加上括号任然存在问题！比如有这么一个宏：

#define DOUBLE(n) (n) + (n)

然后我这么使用：

int ret = 10 * DOUBLE(5);
printf("%d", ret);

预测结果是100，结果却是：

经过前面的分析，大伙也不难分析出问题是怎样产生的，原因就是预编译后替换成了这样：

int ret = 10 * (5) + (5);
printf("%d", ret);

这个问题，的解决办法是在宏定义表达式两边加上一对括号就可以了。

// #define DOUBLE(n) (n) + (n)
#define DOUBLE(n) ((n) + (n))

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

4.#define的替换规则

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

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

其它：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。

#define N 10
#define CAL(x) ((x) + N) 

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#define N 10
#define STR "NOT"
printf("No");

"NOT"中的N并不会被替换，"No"中的N也不会被替换。

3. 对于宏，不能出现递归。

5. 有副作用的宏参数

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

#include 
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main() {
	int a = 10;
	int b = 20;
	int max = MAX(a++, b++);
	printf("%d\n", max);
	printf("%d\n", a);
	printf("%d\n", b);
}

你可能会认为三个输出的结果分别是：20、11和21，理由是a++和b++都是后置++，那么传入的理应是10和20，求出较大值是20，然后a和b自增后分别是11和21，而实际结果是：

将参数替换后倒也很容易发现问题的产生原因：

//int max = MAX(a++, b++);
int max = ((a++) > (b++) ? (a++) : (b++));

(a++) > (b++)比较后肯定为假，但是a和b的值都要被自增为11和21，然后整个表达式的值是b++，b++这个表达式的结果也是b，所以整个表达式的结果是21，但是b++后b要自增为22。

所以在使用宏传参时，应该这么写更合适：

int max = MAX(a + 1, b + 1);

6. 宏与函数的优劣对比

先总结：宏通常被应用于执行简单的运算，比如这种：

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

那为什么不用函数来完成这个任务？

6.1 宏的优点

6.1.1 宏的执行速度更快

用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多，所以宏比函数在程序的规模和速度方面更胜一筹。

说简单点就是调用函数也需要时间，函数返回也需要时间，如果计算工作过于简单，可能函数调用和函数返回的时间都比计算过程花费的时间要长。

①这里使用反汇编直接看汇编代码的行数进行对比，在VS中对下面这段程序进行debug：

②然后右击鼠标，转到反汇编代码：

③查看执行这个宏的汇编代码:

④查看执行这个函数的汇编代码：

⑤这咋一看你会认为好像代码行数更少啊！但仔细看其中有个call指令，这是函数调用指令，所以这并不是真正的函数内部，我们执行到call这一行，f11进入函数内部：

⑥调用函数要进行跳转，这也是一行汇编代码！然后再f11就是真正的函数内部了：

⑦在这里你会发现还没执行到真正的计算，在计算前就存在着某些操作，这些操作实际上是：参数传递、栈空间的创建，然后才是真正的计算！计算的汇编代码才是和宏的汇编代码一样，但是这还没完，函数还有返回，这也是要执行的！

那从函数调用的汇编代码开始算，4行 + 函数跳转1行，+ 函数执行的21行，总共26行，这里实际计算工作其实只有9行。。。。。。

而宏只有十行汇编代码，可以算是只有计算，不存在其它的工作，所以比较高效。

小结一下宏和函数的执行过程：

宏的执行	函数的执行
计算	函数调用与跳转
-	申请创建栈内存空间
-	参数传递
-	计算
-	函数返回

6.1.2 宏不关心参数类型

函数的参数必须声明为特定的类型，而宏是类型无关的。所以函数只能在类型合适的表达式上使用。反之这个宏怎可以适用于整形、长整型、浮点型等可以用于比较操作符来比较的类型。

6.1.2 宏的参数可以出现数据类型

宏有时候可以做函数做不到的事情，比如：宏的参数可以出现类型，但是函数做不到。

例如stddef.h头文件中的宏：offsetof（求结构体成员相对于起始点的字节数）

offsetof宏的使用：

#include 
#include 

struct Test {
	char c;
	int a;
};

int main() {
	printf("%zd\n", offsetof(struct Test, c));
	printf("%zd\n", offsetof(struct Test, a));
  return 0;
}

利用宏简化malloc的使用：

#include 
#include 

#define MALLOC(num, type) (type*)malloc((num) * sizeof(type))

int main() {
	int* pArr1 = (int*)malloc(10 * sizeof(int));
	// 对比一下
	int* pArr2 = MALLOC(10, int);
	return 0;
}

6.2 宏的缺点

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中，除非宏比较短，否则可能大幅度增加程序的长度。
2. 宏是没法调试的，宏在预处理阶段就完成了，不在运行阶段，所以从肉眼上根本无法查看替换后的内容。
3. 宏由于类型无关，也就不够严谨，这个既是优点也是缺点。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

7. 总结宏和函数的对比

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

这么看下来，函数的优势更多，那么是否是直接无脑使用函数就行了呢？还是开头的那句话，如果执行的任务简单，一行代码就能解决的事，还是用宏好一些。

8. 宏的命名约定

一般来讲函数的宏的使用语法很相似，所以语言本身没法帮我们区分二者。

1. 把宏名全部大写
2. 函数名不要全部大写

函数名怎么命名，推荐看《高质量的C/C++编程》这本书！简单来说就是首字母大写，如AddXxx（windows编程风格）；或全小写+下划线_，如add_xxx（Linux编程风格）。