Published by orzz.org(). (http://orzz.org/cxx-macro-play/)
宏（Macro）在C++中是一种非常犀利的工具。如果玩得好了，甚至可以把C++变得很奇怪。。
一、普通玩法
1. 基本功能
定义一个宏来替换字符串：
|
1 |
#define MACRO_PRINTF printf |
这样我们使用MACRO_PRINTF就如同printf一样。
我们还可以像这样定义一个宏名称，但不写任何东西：
|
1 |
#define MACRO_NAME |
然后像这样通过预定义的开关来调整代码实现：
|
1 2 3 |
#ifdef MACRO_NAME #define MACRO_FUNC(x, y) #endif |
我们可以像这样定义一个类似函数的宏：
|
1 |
#define MACRO_SELECT(exp, a, b) ((exp) ? (a) : (b)) |
但是像这样定义的宏定义时需要小心。
比如假如我们定义了一个比较大小的宏如下：
|
1 |
#define MACRO_MAX(a, b) ((a) > (b) ? (a) : (b)) |
像这样使用是不会有问题的：
|
1 |
int n = MACRO_MAX(2, 1); |
但是若是这样使用，就可能会有性能问题：
|
1 2 3 4 5 6 7 8 9 |
int func(int a) { int x = 0; for(int i = 0; i < a; ++i) x += a; return x; } // ... int n = MACRO_MAX(func(10), 99); |
因为我们的func(10)在宏展开中写了两次，因此func内部的循环也执行了两次。
遇到这种情况，函数式的宏就不如真正的函数好用了，比如写一个泛型的大小比较函数：
|
1 2 3 4 5 |
template <typename T> inline const T& max(const T& a, const T& b) { return ((a > b) ? a : b); } |
2. 参数的字符串化和拼接
我们可以像这样把一个宏变成一个字符串：
|
1 |
#define MACRO_STRING(x) #x |
然后宏在碰到#的时候，后面的x就不会被展开。因此这样写可以让任何输入的x都变成字符串。
为了让x展开，我们需要把宏嵌套一层：
|
1 |
#define MACRO_EXPAND(x) MACRO_STRING(x) |
宏在解析的时候，碰到第二层宏，会先展开x，再传递下去。
我们通过MACRO_EXPAND就可以得到x展开之后的样子，并把它变成字符串。
通过这个技巧，可以让我们在程序的运行时观察一个宏展开后的样子：
|
1 |
printf(MACRO_EXPAND(MACRO_FUNC(x))); |
我们还可以把宏输入的两个参数直接连接起来：
|
1 |
#define MACRO_CAT(x, y) x##y |
同样，想要让参数展开后再连接，我们需要这样：
|
1 |
#define MACRO_GLUE(x, y) MACRO_CAT(x, y) |
（在vc里想完全展开参数里的宏，必须在MACRO_EXPAND外面再嵌套一层，否则）
3. 变参宏
C99编译器标准里描述了可变参数的宏，目前主流的编译器也都支持它（gcc还另有一套可变参数宏写法，不过实际用起来大同小异）。
它的语法差不多是这个样子：
|
1 |
#define MACRO_ARGS(...) __VA_ARGS__ |
一般使用起来大概像这样个样子：
|
1 2 3 4 5 |
#ifdef _DEBUG #define MACRO_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__) #else #define MACRO_PRINTF(fmt, ...) #endif // _DEBUG |
若__VA_ARGS__为空，printf会被展开成这样：printf(fmt, )。为了解决这个问题，gcc里的写法是在__VA_ARGS__前面写上##：
|
1 |
#define MACRO_PRINTF(fmt, ...) printf(fmt, ##__VA_ARGS__) |
这样若变参为空时，附带着逗号也会被自动干掉。
vc里对这种写法也支持，不过就按一般的写法（不加##）也不会有问题。vc的编译器在处理变参宏时，若变参为空，会自动删除前面的逗号。
4. __FILE__、__LINE__、__FUNCTION__、...
这些玩意是编译器内置的宏定义。他们分别是：
__FILE__：当前源文件名
__LINE__：当前源代码行号
__FUNCTION__：当前的函数名
__DATE__：当前的编译日期
__TIME__：当前编译时间
__STDC__：当要求程序严格遵循ANSI C标准时该标识被赋值为1
等等。
gcc编译器还支持其他的一些，比如：
__PRETTY_FUNCTION__：当前的函数完整的声明（包含返回值参数表之类）
这样的话，我们可以利用它们写一个调试输出用的宏：
|
1 2 3 4 5 6 7 8 9 10 |
#ifndef __GNUC__ #define __PRETTY_FUNCTION__ __FUNCTION__ #endif #ifdef _DEBUG #define MACRO_TRACE(fmt, ...) printf("%s %s (%d) -> ", __FILE__, __PRETTY_FUNCTION__, __LINE__); printf(fmt, ##__VA_ARGS__) #else #define MACRO_TRACE(fmt, ...) #endif // _DEBUG |
二、文艺玩法
1. 检查函数执行结果
|
1 2 3 4 5 6 |
#define MACRO_CHECK(ensure) if (!(ensure)) { MACRO_TRACE("Check ERROR: %sn", #ensure); } else |
可以这样用：
|
1 2 3 4 5 6 7 8 |
int func(int a) { return 0; } // ... MACRO_CHECK(func(10) > 0); |
若判断错误，则输出函数名加参数以供调试。
还可以在执行成功后让它做后续动作：
|
1 2 3 4 |
MACRO_CHECK(func(10) > 0) { // Do Something } |
2. switch case
用下面的写法可以让switch语句自动输出调试信息，而且还可以省略break：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#define MACRO_CASE(x) break; case x: MACRO_TRACE("%s", #x); // ... int a = 1; switch (a) { default: { // Do something } MACRO_CASE(0) { // Do something } MACRO_CASE(1) { // Do something } MACRO_CASE(2) { // Do something } } |
3. 语法糖
比如实现一个简单的for_each：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
template <typename T, typename U> bool inside(const T& i, const U& set) { return (i <= set); } #define FOR_EACH(type, set) for(type i = 0; inside(i, set); ++i) // ... int x = 0; FOR_EACH(int, 10) { x += i; } printf("%dn", x); |
在这里面我们可以根据类型的不同重载出特定的限制函数来扩充FOR_EACH的功能，也可以使用模板来实现“type i = 0”的自动推导。
4. 简化重复的代码
比如，我们可以通过下面的宏简单方便的为类增加一个属性：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#define PROPERTY_VAR(name) MACRO_CAT(_, name) #define PROPERTY_SET(name) MACRO_GLUE(set, name) #define PROPERTY_GET(name) MACRO_GLUE(get, name)() #define PROPERTY(type, name) type PROPERTY_VAR(name); const type& PROPERTY_SET(name)(const type& param) { if (PROPERTY_VAR(name) != param) PROPERTY_VAR(name) = param; return PROPERTY_VAR(name); } const type& PROPERTY_GET(name) { return PROPERTY_VAR(name); } |
使用方法：
|
1 2 3 4 5 6 7 8 9 10 11 |
class Demo { public: PROPERTY(int, A) }; // ... Demo d; d.PROPERTY_SET(A)(10); printf("%dn", d.PROPERTY_GET(A)); |
三、奇葩玩法
1. 获得宏参数的个数
想要玩出这种效果，是需要动一下脑筋的。。
宏是“死”的，真正意义上的死代码。它没办法像模板那样推导，没办法像函数那样重载，没办法玩递归（编译器发现宏自身的嵌套，会停止展开下一层宏），甚至可变参数对宏来说，都只是一整块无法区分的符号。
那么让我们抛开任意多个参数自动判断的变态想法，来专注实现个数限定下的参数判断吧。
假设我们的参数个数最多不会超过10个，然后有下面的宏MACRO_ARGS：
|
1 |
#define MACRO_ARGS(...) __VA_ARGS__ |
想要计算出__VA_ARGS__里面有多少个参数，最好能够利用宏自身区分参数的机制。
比如我们可以再定义一个宏，然后把它们俩套起来：
|
1 2 |
#define MACRO_ARGS_FILTER(_1,_2,_3,_4,_5,_6,_7,_8,_9) #define MACRO_ARGS_CONTER(...) MACRO_ARGS_FILTER(__VA_ARGS__) |
但是目前FILTER里什么都没有，当CONTER把参数分散放入FILTER时，我们必须要让FILTER能够计算出传入参数的个数才行。
这一步的思维跳跃是比较难思考到的：
|
1 2 |
#define MACRO_ARGS_FILTER(_1,_2,_3,_4,_5,_6,_7,_8,_9,_N, ...) _N #define MACRO_ARGS_CONTER(...) MACRO_ARGS_FILTER(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) |
通过CONTER给FILTER默认10个参数，这时__VA_ARGS__若有1个以上的参数，那么FILTER里的_N就会自动被挤到（9, 8, 7, 6, 5, 4, 3, 2, 1, 0）中合适的位置上。
这样的写法有一个小缺点，就是当参数为空时，CONTER仍然返回1。
想想就知道为什么了：__VA_ARGS__为空时FILTER里的逗号并不会被消掉。
为了让它消掉逗号，在gcc里需要这样写：
|
1 2 |
#define MACRO_ARGS_FILTER(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_N, ...) _N #define MACRO_ARGS_CONTER(...) MACRO_ARGS_FILTER(0, ##__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) |
可以测试一下：
|
1 |
printf("%dn", MACRO_ARGS_CONTER(a, b, c, d)); |
看看它的返回结果是不是4。
当需要更多参数个数的判断时，我们只需要拓展FILTER和CONTER里的数字队列就行了。
上面的写法是gcc下的，在vc里稍有不同：vc编译器在处理__VA_ARGS__的时候，会直接把__VA_ARGS__里的所有内容（包括逗号）作为一整个参数传入下面一个宏里。也就是说，在vc编译器里__VA_ARGS__是不会被展开成参数列表传入第二层的，而是变成了一个大“参数”。
为了让vc能够把__VA_ARGS__打开，我们可以在FILTER的外部包一层什么都不做的宏：
|
1 2 |
#define MACRO_ARGS_(exp) exp #define MACRO_ARGS_CONTER(...) MACRO_ARGS_(MACRO_ARGS_FILTER(0, ##__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)) |
这样的写法就可以同时支持gcc和vc了。
但是其实还有一个小问题。在vc中实际测试的时候可以发现，当CONTER什么都不写的时候，它仍然返回的是1。
这是因为在vc中，虽然在__VA_ARGS__不存在时会自动去掉前面的逗号，但是若是将它作为一个参数传递给下面一层宏的时候，逗号却会被保留下来。
vc不比gcc，可以通过##强制让编译器去掉这个逗号，因此这个小问题在vc里基本无解了。
但是不要紧，一般我们也不会像“CONTER()”这样去调用。至少，现在已经能够成功的自动计算10个以下的参数个数了。
2. 自动生成重复的代码
我们需要实现一个这样的功能：输入一个数字n和一个标识符x，然后得到一个把x连续重复了n次的字符串。
宏定义可以看起来像这个样子：
|
1 |
#define MACRO_N(n, x) |
我们可以先从最简单的做起：当n为0或1时应该是个什么样子。
这个很简单，我们很快可以写出下面的代码：
|
1 2 |
#define MACRO_0(x) #define MACRO_1(x) x |
那么接着，当n为2、3、4的时候呢？
我们可以套用前面的宏，把它们一个个连起来：
|
1 2 3 4 |
#define MACRO_2(x) MACRO_GLUE(x, MACRO_1(x)) #define MACRO_3(x) MACRO_GLUE(x, MACRO_2(x)) #define MACRO_4(x) MACRO_GLUE(x, MACRO_3(x)) // ... |
现在我们有了一堆宏了，下面就需要想办法让MACRO_N能够自动的调用它们：
|
1 |
#define MACRO_N(n, x) MACRO_GLUE(MACRO_, n)(x) |
下面我们可以用printf("%sn", MACRO_EXPAND(MACRO_N(3, str)));来试一试，屏幕上会输出“strstrstr”。
单看这种宏似乎没有什么大用处，但是在一些特殊场景下，这种玩法可以帮我们节省大量的代码。
比如说，在实现仿函数模板的时候，我们会需要“变参模板”的功能，因为一个仿函数模板根本不知道需要支持的函数会有多少个参数。由于目前的主流编译器暂时还不支持C++11标准里的变参模板，因此我们可能需要像下面这样写：
|
1 2 3 4 5 6 7 |
template <typename R> class Functor0; template <typename R, typename T1> class Functor1; template <typename R, typename T1, typename T2> class Functor2; // ... |
这代码。。实在是太蛋疼了。
有了前面那样的技术手段，我们可以先把参数自动拓展的功能玩出来。这需要先把前面那个宏变得更加通用化一些。
考虑到“typename T1, typename T2, typename T3”这样的符号串，必定在开头或结尾，会有一个符号和其他的不同（因为没有分隔用的逗号），通用化一些的宏应该需要再增加一个参数，来代表开头或结尾的特殊串。
这里实现一个以开头作为特殊串的自动化“Repeat”宏（当然，也可以尝试以结尾作为特殊串）：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/* Automate repetitive types of content */ #define REPEAT_0(head, body) #define REPEAT_1(head, body) head(1) #define REPEAT_2(head, body) REPEAT_1(head, body)body(2) #define REPEAT_3(head, body) REPEAT_2(head, body)body(3) #define REPEAT_4(head, body) REPEAT_3(head, body)body(4) #define REPEAT_5(head, body) REPEAT_4(head, body)body(5) #define REPEAT_6(head, body) REPEAT_5(head, body)body(6) #define REPEAT_7(head, body) REPEAT_6(head, body)body(7) #define REPEAT_8(head, body) REPEAT_7(head, body)body(8) #define REPEAT_9(head, body) REPEAT_8(head, body)body(9) #define REPEAT(n,head, body) MACRO_GLUE(REPEAT_, n)(head, body) |
为了实现我们最初的目标，需要预先定义两个待重复的标记并定义一个用来做特殊处理的宏：
|
1 2 3 |
#define TYPENAME_H(n) typename T##n #define TYPENAME_B(n) , typename T##n #define TYPENAME_N(n) REPEAT(n, TYPENAME_H, TYPENAME_B) |
当调用TYPENAME_N(3)的时候，就可以得到“typename T1, typename T2, typename T3”。
现在，可以写一个“自动写代码的宏”了：
|
1 2 |
#define FUNCTOR_N(n) template <typename R, TYPENAME_N(n)> class Functor##n; |
3. 伪变参模板
通过上面的一些手段，我们实现了“任意拓展参数个数”之类的功能，但当参数不同的时候，我们还是需要写不同的模板名来调用功能。
那么如何实现一个像FUNCTOR(...)这样的宏，可以自动根据参数个数选择不同的模板呢？
其实有了前面的第一个计算参数个数的技巧，这样的宏很容易写出来：
|
1 2 3 4 5 |
#define FUNCTOR_1(R) Functor0<R> #define FUNCTOR_2(R, T1) Functor1<R, T1> #define FUNCTOR_3(R, T1, T2) Functor2<R, T1, T2> // ... #define FUNCTOR(...) MACRO_ARGS_(MACRO_GLUE(FUNCTOR_, MACRO_ARGS_CONTER(__VA_ARGS__))(__VA_ARGS__)) |
注意这里不能直接写成这个样子：
|
1 |
#define FUNCTOR(R, ...) MACRO_GLUE(Functor, MACRO_ARGS_CONTER(__VA_ARGS__))<R, ##__VA_ARGS__> |
因为MACRO_ARGS_CONTER在vc下，没有参数的时候始终会返回1，而这里需要0。
但是这个代码还是太累赘了，写到FUNCTOR_9的时候不得不写9个参数。让我们把每个FUNCTOR_的定义都变成一样：
|
1 2 3 4 5 |
#define FUNCTOR_1(...) Functor0<__VA_ARGS__> #define FUNCTOR_N(R, ...) MACRO_GLUE(Functor, MACRO_ARGS_CONTER(__VA_ARGS__))<R, __VA_ARGS__> #define FUNCTOR_2(R, ...) FUNCTOR_N(R, __VA_ARGS__) #define FUNCTOR_3(R, ...) FUNCTOR_N(R, __VA_ARGS__) // ... |
这样我们就可以轻松的拓展支持参数的个数，现在使用Functor可以非常愉快：
|
1 2 3 |
FUNCTOR(int); // Functor0<int> FUNCTOR(void, char*, int); // Functor2<void, char*, int> FUNCTOR(); // Functor0<>, 为Functor0写一个默认的void参数，即可支持无参数的FUNCTOR |
Published by orzz.org(). (http://orzz.org/cxx-macro-play/)
有没有什么办法获取一个宏参数的串长度的办法呢?
如MC_CNT(abc)=3
@陈林熙 没有什么太好的办法。
宏编程本质上是分隔符（,）的计算和宏变量（预编译期符号）的比较。
对于像你的这种不方便划归为此类计算的问题就很难做了。
@mutouyun 也许可以式一下？
#define FOO_STR(arg) (#arg)
#define GETARGLEN(args) (sizeof(FOO_STR(args)) – 1)
@KinoluKaslana 好办法！