C 详解C语言中的宏定义

宏定义的基本用法

无参宏定义：

无参宏定义的一般形式为：#define 标识符 字符串

其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。

例如：　#define M (a+b)　它的作用是指定标识符M来代替表达式(a+b)。在编写源程序时，所有的(a+b)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(a+b)表达式去置换所有的宏名M，然后再进行编译。

#include<stdio.h>#defineM(a+b)intmain(intargc,char*argv[]){ints,a,b;printf("inputnumbera&b:");scanf("%d%d",&a,&b);s=M*M;printf("s=%d\n",s);}

上例程序中首先进行宏定义，定义M来替代表达式(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b) 　但要注意的是，在宏定义中表达式(a+b)两边的括号不能少。否则会发生错误。 　如当作以下定义后：#define M (a)+(b) 　在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b)

带参宏定义：

c语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

带参宏定义的一般形式为： 　#define 宏名(形参表) 字符串

在字符串中含有各个形参。 带参宏调用的一般形式为： 　宏名(形参表)

例如：

<span style="font-size:12px;">#defineM(y)((y)*(y)+3*(y))/*宏定义*/    k=M(5);/*宏调用*/</span>

在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为: 　k=5*5+3*5

//#include<cstdio>#include<stdio.h>#defineMAX(a,b)((a>b)?(a):(b))intmain(intargc,char*argv[]){intx,y,max;printf("inputtwonumbers:");scanf("%d%d",&x,&y);max=MAX(x,y);printf("max=%d\n",max);return0;}

上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式 (a>b)?a:b ，形参a,b均出现在条件表达式中。程序中 max=MAX(x,y) 为宏调用，实参x,y，将代换形参a,b。宏展开后该语句为： max=(x>y)?x:y; 　用于计算x,y中的大数。

#define 条件编译

头文件(.h)可以被头文件或C文件包含；重复包含（重复定义）由于头文件包含可以嵌套，那么C文件就有可能包含多次同一个头文件，就可能出现重复定义的问题的。 通过条件编译开关来避免重复包含（重复定义）

例如

#ifndef__headerfileXXX__#define__headerfileXXX__//文件内容#endif

宏定义的特殊用法

1. 防止一个头文件被重复包含

#ifndef COMDEF_H #define COMDEF_H //头文件内容 #endif 

2. 重新定义一些类型,防止由于各种平台和编译器的不同,而产生的类型字节数差异,方便移植。

typedef  unsigned char      boolean;     /* Boolean value type. */ typedef  unsigned long int  uint32;      /* Unsigned 32 bit value */ typedef  unsigned short     uint16;      /* Unsigned 16 bit value */ typedef  unsigned char      uint8;       /* Unsigned 8  bit value */ typedef  signed long int    int32;       /* Signed 32 bit value */ typedef  signed short       int16;       /* Signed 16 bit value */ typedef  signed char        int8;        /* Signed 8  bit value */ 

3. 得到指定地址上的一个字节或字 

#define  MEM_B( x )  ( *( (int8 *) (x) ) ) #define  MEM_W( x )  ( *( (uint16 *) (x) ) ) 

4. 求最大值和最小值 
    会存在Duplication of Side Effects问题。这里的Side Effect是指宏在展开的时候对其参数可能进行多次Evaluation(也就是取值)，但是如果这个宏参数是一个函数，那么就有可能被调用多次从而达到不一致的结果，甚至会发生更严重的错误。比如：

#define  MAX( x, y ) ( ((x) > (y)) ? (x) : (y) ) #define  MIN( x, y ) ( ((x) < (y)) ? (x) : (y) ) c = min(a,foo(b));

这时foo()函数就被调用了两次。为了解决这个潜在的问题，我们应当这样写min(X,Y)这个宏：

#define min(X,Y) ({\typeof (X) x_ = (X);\typeof (Y) y_ = (Y);\(x_ < y_) ? x_ : y_; })

({...})的作用是将内部的几条语句中最后一条的值返回，它也允许在内部声明变量(因为它通过大括号组成了一个局部Scope)

5,得到一个field在结构体(struct)中的偏移量 

#define FPOS( type, field ) ( (dword) &(( type *) 0)-> field )

6,得到一个结构体中field所占用的字节数

#define FSIZ( type, field ) sizeof( ((type *) 0)->field ) 

7,按照LSB格式把两个字节转化为一个Word 

#define  FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] ) 

8,按照LSB格式把一个Word转化为两个字节

#define<span style="white-space:pre"></span>FLOPW( ray, val ) \ <span style="white-space:pre"></span>(ray)[0] = ((val) / 256); \ <span style="white-space:pre"></span>(ray)[1] = ((val) & 0xFF) 

9,得到一个变量的地址(word宽度) 

#define  B_PTR( var )  ( (int8 *) (void *) &(var) ) #define  W_PTR( var )  ( (uint16 *) (void *) &(var) ) 

10,得到一个字的高位和低位字节

#define  WORD_LO(xxx)  ((byte) ((uint16)(xxx) & 255)) #define  WORD_HI(xxx)  ((byte) ((uint16)(xxx) >> 8)) 

11,返回一个比X大的最接近的8的倍数

#define RND8( x )       ((((x) + 7) / 8 ) * 8 ) 

12,将一个字母转换为大写

#define  UPCASE( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )

13,判断字符是不是10进值的数字

#define  DECCHK( c ) ((c) >= ''0'' && (c) <= ''9'') 

14,判断字符是不是16进值的数字

#define  HEXCHK( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||\                        ((c) >= ''A'' && (c) <= ''F'') ||\        ((c) >= ''a'' && (c) <= ''f'') ) 

15,防止溢出的一个方法

#define  INC_SAT( val )  (val = ((val)+1 > (val)) ? (val)+1 : (val)) 

16,返回数组元素的个数 

#define  ARR_SIZE( a )  ( sizeof( (a) ) / sizeof( (a[0]) ) ) 

17,返回一个无符号数n尾的值

MOD_BY_POWER_OF_TWO(X,n)=X%(2^n) 

#define MOD_BY_POWER_OF_TWO( val, mod_by ) \            ( (dword)(val) & (dword)((mod_by)-1) ) 

18,对于IO空间映射在存储空间的结构,输入输出处理

#define inp(port)         (*((volatile byte *) (port))) #define inpw(port)        (*((volatile word *) (port))) #define inpdw(port)       (*((volatile dword *)(port))) #define outp(port, val)   (*((volatile byte *) (port)) = ((byte) (val))) #define outpw(port, val)  (*((volatile word *) (port)) = ((word) (val))) #define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val))) 

19. 使用一些宏跟踪调试 
ANSI标准说明了五个预定义的宏名。它们是： 
_LINE_
_FILE_ 
_DATE_ 
_TIME_ 
_STDC_ 
如果编译不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序也许还提供其它预定义的宏名。 
_LINE_标识当前代码所在的行号
_FILE_标识代码所在的文件名
_DATE_宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。 
源代码翻译到目标代码的时间作为串包含在_TIME_中。串形式为时：分：秒。 
如果实现是标准的,则宏_STDC_含有十进制常量1。如果它含有任何其它数,则实现是非标准的。 

可以定义宏,例如: 
当定义了_DEBUG,输出数据信息和所在文件所在行 

#ifdef _DEBUG #define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_) #else #define DEBUGMSG(msg,date) #endif 

20. 宏定义防止使用是错误用小括号包含。 
例如：

#define ADD(a,b) (a+b) 

用do{}while(0)语句包含多语句防止错误 
例如：

#difne DO(a,b) a+b; a++; 

应用时：

if(...) DO(a,b); //产生错误 else ...

解决方法:

#define DO(a,b) do{a+b;a++;}while(0) 

21. 宏中"#"和"##"的用法
#的功能是将其后面的宏参数进行字符串化操作(Stringfication)。
##被称为连接符(concatenator)，用来将两个Token连接为一个Token。注意这里连接的对象是Token就行，而不一定是宏的变量。
用法: 

#include<cstdio> #include<climits> using namespace std; #define STR(s)     #s #define CONS(a,b)  int(a##e##b) int main() {     printf(STR(vck));           // 输出字符串"vck"     printf("%d\n", CONS(2,3));  // 2e3 输出:2000     return 0; } 

当宏参数是另一个宏的时候，需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开. 
1) 非''#''和''##''的情况 

#define TOW      (2) #define MUL(a,b) (a*b) printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW)); 

这行的宏会被展开为：

printf("%d*%d=%d\n", (2), (2), ((2)*(2))); 

MUL里的参数TOW会被展开为(2). 

2) 当有''#''或''##''的时候 

#define A          (2) #define STR(s)     #s #define CONS(a,b)  int(a##e##b) printf("int max: %s\n",  STR(INT_MAX));    // INT_MAX #include<climits> 

这行会被展开为：

printf("int max: %s\n", "INT_MAX"); 

printf("%s\n", CONS(A, A));               // compile error  

这一行则是：

printf("%s\n", int(AeA)); 

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 
加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数. 

#define A           (2) #define _STR(s)     #s #define STR(s)      _STR(s)          // 转换宏 #define _CONS(a,b)  int(a##e##b) #define CONS(a,b)   _CONS(a,b)       // 转换宏 printf("int max: %s\n", STR(INT_MAX));          // INT_MAX,int型的最大值,为一个变量 #include<climits> 

输出为: int max: 0x7fffffff 
STR(INT_MAX) -->  _STR(0x7fffffff) 然后再转换成字符串; 

printf("%d\n", CONS(A, A)); 

输出为：200 
CONS(A, A)  -->  _CONS((2), (2))  --> int((2)e(2)) 

3)''#''和''##''的一些应用特例 
i) 合并匿名变量名 

#define  ___ANONYMOUS1(type, var, line)  type  var##line #define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line) #define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__) 

例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示该行行号; 
第一层：ANONYMOUS(static int);  -->  __ANONYMOUS0(static int, __LINE__); 
第二层：                        -->  ___ANONYMOUS1(static int, _anonymous, 70); 
第三层：                        -->  static int  _anonymous70; 
即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开; 

ii) 填充结构 
比如你要做一个菜单项命令名和函数指针组成的结构体的数组，并且希望在函数名和菜单项命令名之间有直观的、名字上的关系。那么下面的代码就非常实用：

struct command{<span style="white-space:pre"></span>char * name;<span style="white-space:pre"></span>void (*function) (void);};#define COMMAND(NAME) { NAME, NAME##_command }

然后你就用一些预先定义好的命令来方便的初始化一个command结构的数组了：

struct command commands[] = {COMMAND(quit),COMMAND(help),...}

COMMAND宏在这里充当一个代码生成器的作用，这样可以在一定程度上减少代码密度，间接地也可以减少不留心所造成的错误。

再比如：

#define  FILL(a)   {a, #a} enum IDD{OPEN, CLOSE}; typedef struct MSG{ <span style="white-space:pre"></span>IDD id; <span style="white-space:pre"></span>const char * msg; }MSG; MSG _msg[] = {FILL(OPEN), FILL(CLOSE)}; 

相当于：

MSG _msg[] = {{OPEN, "OPEN"},               {CLOSE, "CLOSE"}};

iii) 记录文件名

#define  _GET_FILE_NAME(f)   #f #define  GET_FILE_NAME(f)    _GET_FILE_NAME(f) static char  FILE_NAME[] = GET_FILE_NAME(__FILE__); 

iv) 得到一个数值类型所对应的字符串缓冲大小

<pre name="code" class="cpp">#define  _TYPE_BUF_SIZE(type)  sizeof #type #define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)

char  buf[TYPE_BUF_SIZE(INT_MAX)];      -->  char  buf[_TYPE_BUF_SIZE(0x7fffffff)];      -->  char  buf[sizeof "0x7fffffff"]; 

这里相当于：

char  buf[11];

22. 关于...的使用
...在C宏中称为Variadic Macro，也就是变参宏。比如：

#define myprintf(templt,...) fprintf(stderr,templt,__VA_ARGS__)

或者

#define myprintf(templt,args...) fprintf(stderr,templt,args)

第一个宏中由于没有对变参起名，我们用默认的宏__VA_ARGS__来替代它。第二个宏中，我们显式地命名变参为args，那么我们在宏定义中就可以用 args来代指变参了。同C语言的stdcall一样，变参必须作为参数表的最有一项出现。当上面的宏中我们只能提供第一个参数templt时，C标准要求我们必须写成：

myprintf(templt,);

的形式。这时的替换过程为：

myprintf("Error! ",);

替换为：

fprintf(stderr,"Error! ",);

这是一个语法错误，不能正常编译。
这个问题一般有两个解决方法。首先，GNU CPP提供的解决方法允许上面的宏调用写成：

myprintf(templt);

而它将会被通过替换变成：

fprintf(stderr,"Error! ",);

很明显，这里仍然会产生编译错误(非本例的某些情况下不会产生编译错误)。
除了这种方式外，c99和GNU CPP都支持下面的宏定义方式：

#define myprintf(templt, ...) fprintf(stderr,templt, ##__VAR_ARGS__)

这时，##这个连接符号充当的作用就是当__VAR_ARGS__为空的时候，消除前面的那个逗号。那么此时的翻译过程如下：

myprintf(templt);

被转化为：

fprintf(stderr,templt);

这样如果templt合法，将不会产生编译错误。

23.错误的嵌套Misnesting
宏的定义不一定要有完整的、配对的括号，但是为了避免出错并且提高可读性，最好避免这样使用。

24.由操作符优先级引起的问题－Operator Precedence Problem
由于宏只是简单的替换，宏的参数如果是复合结构，那么通过替换之后可能由于各个参数之间的操作符优先级高于单个参数内部各部分之间相互作用的操作符优先级，如果我们不用括号保护各个宏参数，可能会产生预想不到的情形。
比如：

#define ceil_div(x, y) (x + y - 1) / y

那么

a = ceil_div( b & c, sizeof(int) );

将被转化为：

a = ( b & c   + sizeof(int) - 1) / sizeof(int);

由于+/-的优先级高于&的优先级，那么上面式子等同于：

a = ( b & (c + sizeof(int) - 1)) / sizeof(int);

这显然不是调用者的初衷。为了避免这种情况发生，应当多写几个括号：

#define ceil_div(x, y) (((x) + (y) - 1) / (y))

25.消除多余的分号－Semicolon Swallowing
通常情况下，为了使函数模样的宏在表面上看起来像一个通常的C语言调用一样，通常情况下我们在宏的后面加上一个分号，比如下面的带参宏：

MY_MACRO(x);

但是如果是下面的情况：

#define MY_MACRO(x) {\/* line 1 */\/* line 2 */\/* line 3 */ }if (condition())MY_MACRO(a);else{...}

这样会由于多出的那个分号产生编译错误。为了避免这种情况出现同时保持MY_MACRO(x);的这种写法，我们需要把宏定义为这种形式：

#define MY_MACRO(x) do {\/* line 1 */\/* line 2 */\/* line 3 */ } while(0)

这样只要保证总是使用分号，就不会有任何问题。