C++ 基于宏参数的Foreach宏

我想知道是否可以在宏参数上编写宏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__))

---

这是一个递归宏，这是非法的。另一个问题是递归的停止条件。

预处理器的功能不够强大，无法执行类似的操作。但是，您并不真的那么需要预处理器。如果您只想以一种方便的方式转储变量名及其值。您可以有两个简单的宏：

#define PRINT(x) \
{ \
    std::ostringstream stream; \
    stream << x; \
    std::cout << stream.str() << std::endl; \
}

#define VAR(v) #v << ": " << v << ", "

---

有很多方法可以使这个功能更强大，但是这能让你很好地打印非整数值，这是一个相当简单的解决方案。C++中没有扩展的

< P>可以继续，它的序列：

PRINT_ALL((a)(b)(c));

通过对序列使用

BOOST\u PP\u SEQ\u 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) }

---

代码> >定义doxPrime:EOT::CUT

，因为您接受预处理器有VAYARGS（在C99中，但不是在当前C++标准中）可以使用。它完全符合你的要求：P99_。它可以在没有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);

---

使用

PPNARG

，我编写了一组宏，将宏应用于宏中的每个参数。我称之为可变X-宏

/*
 * 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

下面是一些示例，其输出来自注释中的

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)

---

这是整件事的动机。但是它并没有被证明是非常有用的。

是的，递归宏可以在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\u NEXT

宏将单个列表项与特殊的列表结束标记进行比较

（）

。如果项目匹配，宏将返回

MAP\u 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\u GET\u END

宏旁边。如果 这样做形成了一个宏调用，所有内容都会在

MAP\u NEXT0

参数列表，更改输出。

MAP\u 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

和 返回结果

---

为了您的方便，我上传了这段代码。

这是一个老问题，但我想我应该添加一个解决方案，使用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__))

#包括
#包括
#定义_PPSTUFF_OUTVAR1（_var）BOOST_PP_STRINGIZE（_var）“=”您可以使用BOOST.PP（将的
BOOST
文件夹添加到您的包含目录列表中后）获取用于此操作的宏。下面是一个示例（使用GCC 8.1.0进行测试）：

BOOST\u PP\u VARIADIC\u TO_SEQ（\uu VA\u ARGS\uuu）
部分将变量参数列表转换为BOOST将多个参数表示为单个参数的传统方式，如下所示：
（item1）（item2）（item3）

不知道为什么它开始将参数编号为2。本文仅将第一个参数描述为“下一个可用的重复”

下面是另一个示例，它定义了一个
枚举
，能够将其作为字符串写入
ostream
，这也支持Boost的
词法转换
：

第二个是CSee的GNU编译器扩展，你可以用逗号运算符在C++中解决这个问题，更好些。@ Junnes：不包括字符串变量名（或表达式，或…）。PP足够强大，例如使用BooSt.pp序列。
#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__)

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

#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

#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!

#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