分类: C/C++
2009-03-23 15:17:49
#
、##
运算符和可变参数在函数式宏定义中,#
运算符用于创建字符串,#
运算符后面应该跟一个形参(中间可以有空格或Tab),例如:
#define STR(s) # s STR(hello world)
用cpp
命令预处理之后是"hello world"
,自动用"
号把实参括起来成为一个字符串,并且实参中的连续多个空白字符被替换成一个空格。
再比如:
#define STR(s) #s fputs(STR(strncmp("ab\"c\0d", "abc", '\4"') == 0) STR(: @\n), s);
预处理之后是fputs("strncmp(\"ab\\\"c\\0d\", \"abc\", '\\4\"') == 0" ": @\n", s);
,注意如果实参中包含字符常量或字符串,则宏展开之后字符串的界定符"
要替换成\"
,字符常量或字符串中的\
和"
字符要替换成\\
和\"
。
在宏定义中可以用##
运算符把前后两个预处理Token连接成一个预处理Token,和#
运算符不同,##
运算符不仅限于函数式宏定义,变量式宏定义也可以用。例如:
#define CONCAT(a, b) a##b CONCAT(con, cat)
预处理之后是concat
。再比如,要定义一个宏展开成两个#
号,可以这样定义:
#define HASH_HASH # ## #
中间的##
是运算符,宏展开时前后两个#
号被这个运算符连接在一起。注意中间的两个空格是不可少的,如果写成####
,会被划分成##
和##
两个Token,而根据定义##
运算符用于连接前后两个预处理Token,不能出现在宏定义的开头或末尾,所以会报错。
我们知道printf
函数带有可变参数,函数式宏定义也可以带可变参数,同样是在参数列表中用...
表示可变参数。例如:
#define showlist(...) printf(#__VA_ARGS__) #define report(test, ...) ((test)?printf(#test):\ printf(__VA_ARGS__)) showlist(The first, second, and third items.); report(x>y, "x is %d but y is %d", x, y);
预处理之后变成:
printf("The first, second, and third items."); ((x>y)?printf("x>y"): printf("x is %d but y is %d", x, y));
在宏定义中,可变参数的部分用__VA_ARGS__
表示,实参中对应...
的几个参数可以看成一个参数替换到宏定义中__VA_ARGS__
所在的地方。
调用函数式宏定义允许传空参数,这一点和函数调用不同,通过下面几个例子理解空参数的用法。
#define FOO() foo FOO()
预处理之后变成foo
。FOO
在定义时不带参数,在调用时也不允许传参数给它。
#define FOO(a) foo##a FOO(bar) FOO()
预处理之后变成:
foobar foo
FOO
在定义时带一个参数,在调用时必须传一个参数给它,如果不传参数则表示传了一个空参数。
#define FOO(a, b, c) a##b##c FOO(1,2,3) FOO(1,2,) FOO(1,,3) FOO(,,3)
预处理之后变成:
123 12 13 3
FOO
在定义时带三个参数,在调用时也必须传三个参数给它,空参数的位置可以空着,但必须给够三个参数,FOO(1,2)
这样的调用是错误的。
#define FOO(a, ...) a##__VA_ARGS__ FOO(1) FOO(1,2,3,)
预处理之后变成:
1 12,3,
FOO(1)
这个调用相当于可变参数部分传了一个空参数,FOO(1,2,3,)
这个调用相当于可变参数部分传了三个参数,第三个是空参数。
gcc
有一种扩展语法,如果##
运算符用在__VA_ARGS__
前面,除了起连接作用之外还有特殊的含义,例如内核代码net/netfilter/nf_conntrack_proto_sctp.c
中的:
#define DEBUGP(format, ...) printk(format, ## __VA_ARGS__)
printk
这个内核函数相当于printf
,也带有格式化字符串和可变参数,由于内核不能调用libc
的函数,所以另外实现了一个打印函数。这个函数式宏定义可以这样调用:DEBUGP("info no. %d", 1)
。也可以这样调用:DEBUGP("info")
。后者相当于可变参数部分传了一个空参数,但展开后并不是printk("info",)
,而是printk("info")
,当__VA_ARGS
是空参数时,##
运算符把它前面的,
号“吃”掉了。
以上举的宏展开的例子都是最简单的,有些宏展开的过程要做多次替换,例如:
#define sh(x) printf("n" #x "=%d, or %d\n",n##x,alt[x]) #define sub_z 26 sh(sub_z)
sh(sub_z)
要用sh(x)
这个宏定义来展开,形参x
对应的实参是sub_z
,替换过程如下:
#x
要替换成"sub_z"
。
n##x
要替换成nsub_z
。
除了带#
和##
运算符的参数之外,其它参数在替换之前要对实参本身做充分的展开,所以应该先把sub_z
展开成26再替换到alt[x]
中x
的位置。
现在展开成了printf("n" "sub_z" "=%d, or %d\n",nsub_z,alt[26])
,所有参数都替换完了,这时编译器会再扫描一遍,再找出可以展开的宏定义来展开,假设nsub_z
或alt
是变量式宏定义,这时会进一步展开。
再举一个例子:
#define x 3 #define f(a) f(x * (a)) #undef x #define x 2 #define g f #define t(a) a t(t(g)(0) + t)(1);
展开的步骤是:
先把g
展开成f
再替换到#define t(a) a
中,得到t(f(0) + t)(1);
。
根据#define f(a) f(x * (a))
,得到t(f(x * (0)) + t)(1);
。
把x
替换成2,得到t(f(2 * (0)) + t)(1);
。注意,一开始定义x
为3,但是后来用#undef x
取消了x
的定义,又重新定义x
为2。当处理到t(t(g)(0) + t)(1);
这一行代码时x
已经定义成2了,所以用2来替换。还要注意一点,现在得到的t(f(2 * (0)) + t)(1);
中仍然有f
,但不能再次根据#define f(a) f(x * (a))
展开了,f(2 * (0))
就是由展开f(0)
得到的,这里面再遇到f
就不展开了,这样规定可以避免无穷展开(类似于无穷递归),因此我们可以放心地使用递归定义,例如#define a a[0]
,#define a a.member
等。
根据#define t(a) a
,最终展开成f(2 * (0)) + t(1);
。这时不能再展开t(1)
了,因为这里的t
就是由展开t(f(2 * (0)) + t)
得到的,所以不能再展开了。