关于宏参数的Foreach宏

Question

我想知道是否有可能在宏参数上编写宏foreach.这是想做的事情:

#define PRINT(a) printf(#a": %d", a)
#define PRINT_ALL(...) ? ? ? THE PROBLEM ? ? ? 

可能的用法:

int a = 1, b = 3, d = 0;
PRINT_ALL(a,b,d);

这是我到目前为止所取得的成就

#define FIRST_ARG(arg,...) arg
#define AFTER_FIRST_ARG(arg,...) , ##__VA_ARGS__     
#define PRINT(a) printf(#a": %d", a)
#define PRINT_ALL PRINT(FIRST_ARG(__VA_ARGS__)); PRINT_ALL(AFTER_FIRST_ARG(__VA_ARGS__))

这是一个递归宏,这是非法的.另一个问题是stop condition递归.

Answer 1

是的,使用花哨的解决方法可以在C中使用递归宏.最终目标是创建一个MAP像这样工作的宏:

#define PRINT(a) printf(#a": %d", a)
MAP(PRINT, a, b, c) /* Apply PRINT to a, b, and c */

基本递归

首先,我们需要一种技术来发出看起来像宏调用的东西,但还没有:

#define MAP_OUT

想象一下,我们有以下宏:

#define A(x) x B MAP_OUT (x)
#define B(x) x A MAP_OUT (x)

评估宏A (blah)会生成输出文本:

blah B (blah)

预处理器没有看到任何递归,因为此时B (blah)调用只是纯文本,B甚至不是当前宏的名称.将此文本反馈到预处理器会扩展调用,从而生成输出:

blah blah A (blah)

第三次评估输出扩展A (blah)宏,携带递归全圆.只要调用者继续将输出文本反馈到预处理器,递归就会继续.

要执行这些重复的计算,下面的EVAL宏将其参数传递给宏调用树:

#define EVAL0(...) __VA_ARGS__
#define EVAL1(...) EVAL0 (EVAL0 (EVAL0 (__VA_ARGS__)))
#define EVAL2(...) EVAL1 (EVAL1 (EVAL1 (__VA_ARGS__)))
#define EVAL3(...) EVAL2 (EVAL2 (EVAL2 (__VA_ARGS__)))
#define EVAL4(...) EVAL3 (EVAL3 (EVAL3 (__VA_ARGS__)))
#define EVAL(...)  EVAL4 (EVAL4 (EVAL4 (__VA_ARGS__)))

每个级别乘以之前级别的工作量,总共评估输入365次.换句话说,调用EVAL (A (blah))会生成365个单词的副本blah,然后是最终未评估的单词B (blah).这为递归提供了基本框架,至少在一定的堆栈深度内.

结束检测

下一个挑战是在到达列表末尾时停止递归.

基本的想法是在退出时发出以下宏名称而不是正常的递归宏:

#define MAP_END(...)

评估此宏不会做什么,这会结束递归.

要在两个宏之间进行实际选择,以下MAP_NEXT 宏将单个列表项与特殊的列表末尾标记进行比较 ().MAP_END如果项匹配则返回宏,next 如果项是其他任何内容则返回参数:

#define MAP_GET_END() 0, MAP_END
#define MAP_NEXT0(item, next, ...) next MAP_OUT
#define MAP_NEXT1(item, next) MAP_NEXT0 (item, next, 0)
#define MAP_NEXT(item, next)  MAP_NEXT1 (MAP_GET_END item, next)

此宏通过将项目放在MAP_GET_END宏旁边来工作.如果这样做形成一个宏调用,一切都会通过MAP_NEXT0参数列表中的一个插槽移动 ,从而改变输出.该MAP_OUT技巧可防止预处理器评估最终结果.

全部放在一起

有了这些部分,现在可以从上面的例子中实现A和B宏的有用版本:

#define MAP0(f, x, peek, ...) f(x) MAP_NEXT (peek, MAP1) (f, peek, __VA_ARGS__)
#define MAP1(f, x, peek, ...) f(x) MAP_NEXT (peek, MAP0) (f, peek, __VA_ARGS__)

这些宏将操作f应用于当前列表项x.然后他们检查下一个列表项,peek看看它们是否应该继续.

最后一步是在顶级MAP宏中将所有内容绑定在一起:

#define MAP(f, ...) EVAL (MAP1 (f, __VA_ARGS__, (), 0))

此宏()在列表的末尾放置一个标记,以及0ANSI合规性的额外标记 (否则,最后一次迭代将具有非法的0长度列表).然后它传递整个事物EVAL并返回结果.

为方便起见,我已将此代码作为库上传到github上.

Answer 2

使用PPNARG,我编写了一组宏来将宏应用于宏中的每个参数.我把它称为可变的X-macro.

/*
 * The PP_NARG macro evaluates to the number of arguments that have been
 * passed to it.
 *
 * Laurent Deniau, "__VA_NARG__," 17 January 2006, <comp.std.c> (29 November 2007).
 */
#define PP_NARG(...)    PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...)   PP_ARG_N(__VA_ARGS__)

#define PP_ARG_N( \
        _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,_26,_27,_28,_29,_30, \
        _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
        _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
        _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
        _61,_62,_63,N,...) N

#define PP_RSEQ_N() \
        63,62,61,60,                   \
        59,58,57,56,55,54,53,52,51,50, \
        49,48,47,46,45,44,43,42,41,40, \
        39,38,37,36,35,34,33,32,31,30, \
        29,28,27,26,25,24,23,22,21,20, \
        19,18,17,16,15,14,13,12,11,10, \
        9,8,7,6,5,4,3,2,1,0

PPNARG让我们计算一下有多少参数.然后我们将该数字附加到宏名称并使用原始参数调用它.

/* need extra level to force extra eval */
#define Paste(a,b) a ## b
#define XPASTE(a,b) Paste(a,b)


/* APPLYXn variadic X-Macro by M Joshua Ryan      */
/* Free for all uses. Don't be a jerk.            */
/* I got bored after typing 15 of these.          */
/* You could keep going upto 64 (PPNARG's limit). */
#define APPLYX1(a)           X(a)
#define APPLYX2(a,b)         X(a) X(b)
#define APPLYX3(a,b,c)       X(a) X(b) X(c)
#define APPLYX4(a,b,c,d)     X(a) X(b) X(c) X(d)
#define APPLYX5(a,b,c,d,e)   X(a) X(b) X(c) X(d) X(e)
#define APPLYX6(a,b,c,d,e,f) X(a) X(b) X(c) X(d) X(e) X(f)
#define APPLYX7(a,b,c,d,e,f,g) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g)
#define APPLYX8(a,b,c,d,e,f,g,h) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h)
#define APPLYX9(a,b,c,d,e,f,g,h,i) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i)
#define APPLYX10(a,b,c,d,e,f,g,h,i,j) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j)
#define APPLYX11(a,b,c,d,e,f,g,h,i,j,k) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k)
#define APPLYX12(a,b,c,d,e,f,g,h,i,j,k,l) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l)
#define APPLYX13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m)
#define APPLYX14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m) X(n)
#define APPLYX15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m) X(n) X(o)
#define APPLYX_(M, ...) M(__VA_ARGS__)
#define APPLYXn(...) APPLYX_(XPASTE(APPLYX, PP_NARG(__VA_ARGS__)), __VA_ARGS__)

以下是gcc -E注释中输出的一些示例.

/* Example */
#define X(a) #a,
char *list[] = {
    APPLYXn(sugar,coffee,drink,smoke)
};
#undef X

/* Produces (gcc -E)
char *list[] = {
    "sugar", "coffee", "drink", "smoke",
};
 */


#define c1(a) case a:
#define c2(a,b)     c1(a) c1(b)
#define c3(a,b,c)   c1(a) c2(b,c)
#define c4(a,b,c,d) c1(a) c3(b,c,d)
#define c_(M, ...) M(__VA_ARGS__)
#define cases(...) c_(XPASTE(c, PP_NARG(__VA_ARGS__)), __VA_ARGS__)


//cases(3,4,5,6,7)
//produces
//case 3: case 4: case 5: case 6:


#define r_(a,b) range(a,b)
#define range(a,b) a,r_(a+1,b-1)
//range(3,4)

#define ps1(a) O ## a ();
#define ps2(a,b)     ps1(a) ps1(b)
#define ps3(a,b,c)   ps1(a) ps2(b,c)
#define ps4(a,b,c,d) ps1(a) ps3(b,c,d)
#define ps_(M, ...) M(__VA_ARGS__)
#define ps(...)     ps_(XPASTE(ps, PP_NARG(__VA_ARGS__)), __VA_ARGS__)

//ps(dup,add,sub)

这最后是整个事情的动机.但它并没有变得非常有用.

Answer 3

由于您接受预处理器具有VA_ARGS(在C99中,但在当前的C++标准中),您可以使用P99.它正是你要求的:P99_FOR.它没有()()()BOOST 的粗略语法.界面就是

P99_FOR(NAME, N, OP, FUNC,...) 

并且你可以使用类似的东西

#define P00_SEP(NAME, I, REC, RES) REC; RES
#define P00_VASSIGN(NAME, X, I) X = (NAME)[I]
#define MYASSIGN(NAME, ...) P99_FOR(NAME, P99_NARG(__VA_ARGS__), P00_SEP, P00_VASSIGN, __VA_ARGS__)

MYASSIGN(A, toto, tutu);