宏定义——精选推荐

宏定义
宏定义是C提供的三种预处理功能的其中⼀种，这三种预处理包括：宏定义、⽂件包含、条件编译。

1.不带参数的宏定义：
宏定义⼜称为宏代换、宏替换，简称“宏”。

格式： #define 标识符字符串
其中的标识符就是所谓的符号常量，也称为“宏名”，字符串可以是常数、表达式、格式串等。

在编译预处理时，对程序中所有出现的“宏名”，都⽤宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。

宏定义是由源程序中的宏定义命令完成的。

宏代换是由预处理程序⾃动完成的。

掌握"宏"概念的关键是“换”。

⼀切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。

即在对相关命令或语句的含义和功能作具体分析之前就要换：
例： #define PI 3.1415926
把程序中出现的PI全部换成3.1415926
说明：
（1）宏名⼀般⽤⼤写；
（2）使⽤宏可提⾼程序的通⽤性和易读性，减少不⼀致性，减少输⼊错误和便于修改。

例如：数组⼤⼩常⽤宏定义；
（3）预处理是在编译之前的处理，⽽编译⼯作的任务之⼀就是语法检查，预处理不做语法检查；
（4）宏定义末尾不加分号；　
（5）宏定义写在函数的花括号外边，作⽤域为其后的程序，通常在⽂件的最开头；
（6）可以⽤#undef命令终⽌宏定义的作⽤域；
（7）宏定义可以嵌套；
（8）字符串" "中永远不包含宏；
（9）宏定义不分配内存，变量定义分配内存；
（10）宏定义不存在类型问题，它的参数也是⽆类型的。

2.带参数的宏定义（函数式宏定义）：
除了⼀般的字符串替换，还要做参数代换。

若字符串是表达式，我们称之为函数式宏定义。

格式：
#define 宏名（参数表）字符串
2.1 例如：#define S(a,b) a*b
area=S(3,2)；第⼀步被换为area=a*b; ，第⼆步被换为area=3*2;
类似于函数调⽤，有⼀个哑实结合的过程：
（1）实参如果是表达式容易出问题 #define S(r) r*r area=S(a+b);第⼀步换为area=r*r;,第⼆步被换为area=a+b*a+b;
正确的宏定义是#define S(r) ((r)*(r))
（2）宏名和参数的括号间不能有空格
（3）宏替换只作替换，不做计算，不做表达式求解
（4）函数调⽤在编译后程序运⾏时进⾏，并且分配内存。

宏替换在编译前进⾏，不分配内存
（5）宏的哑实结合不存在类型，也没有类型转换。

（6）函数只有⼀个返回值，利⽤宏则可以设法得到多个值
（7）宏展开使源程序变长，函数调⽤不会
（8）宏展开不占运⾏时间，只占编译时间，函数调⽤占运⾏时间（分配内存、保留现场、值传递、返回值）
2.2 下⾯⽐较函数式宏定义和普通函数的区别：
函数式宏定义：#define MAX(a,b) ((a)>(b)?(a):(b))
普通函： MAX(a,b) { return a>b?a:b;}
（1）函数式宏定义的参数没有类型，预处理器只负责做形式上的替换，⽽不做参数类型检查，所以传参时要格外⼩⼼。

（2）调⽤真正函数的代码和调⽤函数式宏定义的代码编译⽣成的指令不同。

如果MAX是个普通函数，那么它的函数体return a > b ? a : b; 要编译⽣成指令，代码中出现的每次调⽤也要编译⽣成传参指令和call指令。

⽽如果MAX是个函数式宏定义，这个宏定义本⾝倒不必编译⽣成指令，但是代码中出现的每次调⽤编译⽣成的指令都相当于⼀个函数体，⽽不是简单的⼏条传参指令和call指令。

所以，使⽤函数式宏定义编译⽣成的⽬标⽂件会⽐较⼤。

（3）函数式宏定义要注意格式，尤其是括号。

如果上⾯的函数式宏定义写成 #define MAX(a, b) (a>b?a:b)，省去内层括号，则宏展开就成了k = (i&0x0f>j&0x0f?i&0x0f:j&0x0f)，运算的优先级就错了。

同样道理，这个宏定义的外层括号也是不能省的。

若函数中是宏替换为 ++MAX(a,b)，则宏展开就成了 ++(a)>(b)?(a):(b)，运算优先级也是错了。

（4）若函数参数为表达式，则普通函数的调⽤与函数式宏定义的替换过程是不⼀样的。

普通函数调⽤时先求实参表达式的值再传给形参，如果实参表达式有Side Effect，那么这些SideEffect只发⽣⼀次。

例如MAX(++a, ++b)，如果MAX是普通函数，a和b只增加⼀次。

但如果MAX函数式宏定义，则要展开成k = ((++a)>(++b)?(++a):(++b))，a和b就不⼀定是增加⼀次还是两次了。

所以若参数是表达式，替换函数式宏定义时⼀定要仔细看好。

（5）函数式宏定义往往会导致较低的代码执⾏效率：
#define MAX(a, b) ((a)>(b)?(a):(b))
int a[] = { 9, 3, 5, 2, 1, 0, 8, 7, 6, 4 };
int max(int n)
{
return n == 0 ? a[0] : MAX(a[n], max(n-1));
}
int main(void)
{
max(9);
return0;
}
若是普通函数，则通过递归，可取的最⼤值，时间复杂度为O（n）。

但若是函数式宏定义，则宏展开为( a[n]>max(n-1)?a[n]:max(n-1) )，其中max(n-1)被调⽤了两遍，这样依此递归下去，时间复杂度会很⾼。

尽管函数式宏定义和普通函数相⽐有很多缺点，但只要⼩⼼使⽤还是会显著提⾼代码的执⾏效率，毕竟省去了分配和释放栈帧、传参、传返回值等⼀系列⼯作，因此那些简短并且被频繁调⽤的函数经常⽤函数式宏定义来代替实现。

3.宏定义其他冷门、重点知识
#define⽤法
3.1 ⽤⽆参宏定义⼀个简单的常量
#define LEN 12 这个是最常见的⽤法，但也会出错。

⽐如下⾯⼏个知识点你会吗？可以看下：
（1） #define NAME "zhangyuncong"
程序中有"NAME"则，它会不会被替换呢？
（2） #define 0x abcd 可以吗？也就是说，可不可以⽤把标识符的字母替换成别的东西？
（3） #define NAME "zhang 这个可以吗？
（4） #define NAME "zhangyuncong"
程序中有上⾯的宏定义，并且，程序⾥有句： NAMELIST这样，会不会被替换成"zhangyuncong"LIST
四个题答案都是⼗分明确的。

第⼀个，""内的东西不会被宏替换。

这⼀点应该⼤都知道。

第⼆个，宏定义前⾯的那个必须是合法的⽤户标识符
第三个，宏定义也不是说后⾯东西随便写，不能把字符串的两个""拆开。

第四个：只替换标识符，不替换别的东西。

NAMELIST整体是个标识符，⽽没有NAME标识符，所以不替换。

也就是说，这种情况下记住：#define 第⼀位置第⼆位置
（1）不替换程序中字符串⾥的东西。

（2）第⼀位置只能是合法的标识符（可以是关键字）
（3）第⼆位置如果有字符串，必须把""配对。

（4）只替换与第⼀位置完全相同的标识符
还有就是⽼⽣常谈的话：记住这是简单的替换⽽已，不要在中间计算结果，⼀定要替换出表达式之后再算。

3.2 带参宏⼀般⽤法
⽐如#define MAX(a,b) ((a)>(b)?(a):(b))
则遇到MAX(1+2,value)则会把它替换成： ((1+2)>(value)?(1+2):(value))
注意事项和⽆参宏差不多。

但还是应注意
#define FUN(a) "a" 则，输⼊FUN(345)会被替换成什么？
其实，如果这么写，⽆论宏的实参是什么，都不会影响其被替换成"a"的命运。

也就是说，""内的字符不被当成形参，即使它和⼀模⼀样。

那么，你会问了，我要是想让这⾥输⼊FUN(345)它就替换成"345"该怎么实现呢？请看下⾯关于#的⽤法
3.3 有参宏定义中#的⽤法
#define STR(str) #str
#⽤于把宏定义中的参数两端加上字符串的""
⽐如，这⾥STR(my#name)会被替换成"my#name"
⼀般由任意字符都可以做形参，但以下情况会出错：
STR())这样，编译器不会把“)”当成STR()的参数。

STR(,)同上，编译器不会把“,”当成STR的参数。

STR(A,B)如果实参过多，则编译器会把多余的参数舍去。

（VC++2008为例） STR((A,B))会被解读为实参为：(A,B)，⽽不是被解读为两个实参，第⼀个是(A第⼆个是B)。

3.4 有参宏定义中##的⽤法
#define WIDE(str) L##str 则会将形参str的前⾯加上L
⽐如：WIDE("abc")就会被替换成L"abc"
如果有#define FUN(a,b) vo##a##b()
那么FUN(id ma,in)会被替换成void main()
3.5 多⾏宏定义：
#define doit(m,n) for(int i=0;i<(n);++i)\ {\ m+=i;\ }。