我想知道是否可以在宏参数上编写宏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递归。
答案 0 :(得分：39)
是的，使用花哨的解决方法可以在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))会
生成单词blah的365个副本，然后是最终未评估的B (blah)。这提供了递归的基本框架，至少在a
一定的堆栈深度。
接下来的挑战是在递归到达结束时停止递归 列表。
基本思想是发出以下宏名称而不是正常名称 退出时的递归宏：
#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))
此宏在列表的末尾放置一个()标记，以及一个额外的标记
0符合ANSI标准（否则，最后一次迭代将是非法的
0长度列表）。然后它通过EVAL传递整个事物
返回结果。
为方便起见，我已将此代码上传为library on github。
答案 1 :(得分：8)
使用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)
这最后是整个事情的动机。但它并没有变得非常有用。
答案 2 :(得分：6)
由于您接受预处理器具有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);
答案 3 :(得分：4)
在没有扩展名的C ++中，你可以选择Boost.Preprocessor并且它是序列：
PRINT_ALL((a)(b)(c));
通过在序列上使用BOOST_PP_SEQ_FOR_EACH()，您可以迭代它并轻松生成打印它们的代码。
未经测试的直接样本：
#define DO_PRINT(elem) std::cout << BOOST_PP_STRINGIZE(elem) << "=" << (elem) << "\n";
#define PRINT_ALL(seq) { BOOST_PP_SEQ_FOR_EACH(DO_PRINT, _, seq) }
答案 4 :(得分：3)
老问题，但我想我会提出一个解决方案，我提出使用Boost.Preprocessor而不使用丑陋的(a)(b)语法。
部首：
#include <iostream>
#include <boost\preprocessor.hpp>
#define _PPSTUFF_OUTVAR1(_var) BOOST_PP_STRINGIZE(_var) " = " << (_var) << std::endl
#define _PPSTUFF_OUTVAR2(r, d, _var) << _PPSTUFF_OUTVAR1(_var)
#define _PPSTUFF_OUTVAR_SEQ(vseq) _PPSTUFF_OUTVAR1(BOOST_PP_SEQ_HEAD(vseq)) \
BOOST_PP_SEQ_FOR_EACH(_PPSTUFF_OUTVAR2,,BOOST_PP_SEQ_TAIL(vseq))
#define OUTVAR(...) _PPSTUFF_OUTVAR_SEQ(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
用法：
int a = 3;
char b[] = "foo";
std::cout << OUTVAR(a);
// Expands to:
//
// std::cout << "a" " = " << (a ) << std::endl ;
//
// Output:
//
// a = 3
std::cout << OUTVAR(a, b);
// Expands to:
//
// std::cout << "a" " = " << (a ) << std::endl << "b" " = " << (b) << std::endl ;
//
// Output:
//
// a = 3
// b = foo
很干净。
当然，如果您想在一行中使用逗号，可以用逗号或其他内容替换std::endl。
答案 5 :(得分：2)
预处理器不够强大，不能做这样的事情。但是，您并不需要那么糟糕的预处理器。如果您只想以方便的方式转储变量名称及其值。你可以有两个简单的宏：
#define PRINT(x) \
{ \
std::ostringstream stream; \
stream << x; \
std::cout << stream.str() << std::endl; \
}
#define VAR(v) #v << ": " << v << ", "
然后您几乎可以使用您的预期用途：
int a = 1, b = 3, d = 0;
PRINT(VAR(a) << VAR(b) << VAR(d))
打印
a: 1, b: 3, d: 0,
有很多方法可以让它变得更强大，但是这样可以很好地打印非整数值，这是一个相当简单的解决方案。
答案 6 :(得分：1)
您可以使用Boost.PP（在将Boost的boost文件夹添加到包含目录列表之后）来获取宏。这是一个示例（经过GCC 8.1.0测试）：
#include <iostream>
#include <limits.h>
#include <boost/preprocessor.hpp>
#define WRITER(number,middle,elem) std::cout << \
number << BOOST_PP_STRINGIZE(middle) << elem << "\n";
#define PRINT_ALL(...) \
BOOST_PP_SEQ_FOR_EACH(WRITER, =>, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
int main (int argc, char *argv[])
{
PRINT_ALL(INT_MAX, 123, "Hello, world!");
}
输出：
2=>2147483647
3=>123
4=>Hello, world!
BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)部分将变量参数列表转换为Boost的传统方式，即将多个参数表示为单个参数，如下所示：(item1)(item2)(item3)。
不确定为什么要开始将参数编号为2。 documentation仅将第一个参数描述为“下一个可用的BOOST_PP_FOR重复”。
这是另一个示例，它定义了一个enum，并能够将其作为字符串写入ostream，这也启用了Boost的lexical_cast<string>：
#define ENUM_WITH_TO_STRING(ENUMTYPE, ...) \
enum ENUMTYPE { \
__VA_ARGS__ \
}; \
inline const char* to_string(ENUMTYPE value) { \
switch (value) { \
BOOST_PP_SEQ_FOR_EACH(_ENUM_TO_STRING_CASE, _, \
BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
default: return nullptr; \
} \
} \
inline std::ostream& operator<<(std::ostream& os, ENUMTYPE v)\
{ return os << to_string(v); }
#define _ENUM_TO_STRING_CASE(_,__,elem) \
case elem: return BOOST_PP_STRINGIZE(elem);
ENUM_WITH_TO_STRING(Color, Red, Green, Blue)
int main (int argc, char *argv[])
{
std::cout << Red << Green << std::endl;
std::cout << boost::lexical_cast<string>(Blue) << std::endl;
}
输出：
RedGreen
Blue