3

我想定义一个带有可变数量参数的宏，它打印每个给定参数的名称和值。

例如 ：

MACRO(x)会打印x = 123 MACRO(x,y)会打印x,y = 123,666

更好的宏将更具可读性

BETTER_MACRO(x,y)会打印x = 123, y = 666

对于一个变量，我可以通过以下方式进行管理：

#define MACRO(...) cout << #__VA_ARGS__ << " = " << __VA_ARGS__ << endl;

更多，它不起作用。

通过这种方式，我想到了一些辅助问题。

1）如何获得赋予宏的变量数量？2）如何访问每个参数？

天真地猜测，我们可以回答这两个问题。

然后我们希望通过以下方式定义宏。

#define BETTER_MACRO(...) {for (int i=0;i<=nb_variables;i++) {cout << #var[i] << var[i];}}

4

5 回答 5

6 
#define MACRO(...) function(#__VA_ARGS__, __VA_ARGS__)

// base case for template recursion when one argument remains
template <typename Arg1>
void function(const char* name, Arg1&& arg1)
{
    std::cout << name << " = " << arg1 << std::endl;
}

// recursive variadic template for multiple arguments
template <typename Arg1, typename... Args>
void function(const char* names, Arg1&& arg1, Args&&... args)
{
    const char* comma = strchr(names + 1, ',');
    std::cout.write(names, comma - names) << " = " << arg1;
    function(comma, args...);
}

上面有一些异想天开的属性，即您在 MACRO 调用中包含的任何间距（或不包含）都将反映在输出中。

于 2014-04-09T14:12:29.157 回答
3

1）如何获得赋予宏的变量数量？

您可以使用类似这样的方法来计算元素：（使用硬编码限制）：

#define COUNT_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...)    N
#define COUNT(...)   COUNT_N(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
// Warning: COUNT() return 1 (as COUNT(A)) :-/

2）如何访问每个参数？

/* args */
#define ARG(N, ...) ARG_##N(__VA_ARGS__)

#define ARG_1(a, ...) a
#define ARG_2(a, b,...) b
#define ARG_3(a, b, c, ...) c
#define ARG_4(a, b, c, d, ...) d
#define ARG_5(a, b, c, d, e, ...) e
#define ARG_6(a, b, c, d, e, f, ...) f
#define ARG_7(a, b, c, d, e, f, g, ...) g
#define ARG_8(a, b, c, d, e, f, g, h, ...) h
于 2014-04-09T14:17:59.923 回答
1

不是一个理想的解决方案，但是：

宏本身可以采用固定数量的参数，但每个参数都可以是一个带括号的列表（即使它只是一个文本字符串）。

 void function_taking_varargs(...);

 #define SLIGHTLY_BETTER(x) \
      function_taking_varargs x


 SLIGHTLY_BETTER((a, b, c));
于 2014-04-09T14:04:06.250 回答
1

这个在 C++11 之前工作，没有丑陋的可变参数函数。相反，它使用丑陋的宏，这至少会产生编译时错误。调用语法有点不同，但并没有太多。我尝试寻找类似的东西SEQ_ENUM，但使用宏，但找不到任何东西。

首先，我们将制作自定义的打印宏：

#define PRINT_ONE(elem) BOOST_PP_STRINGIZE(elem) " = " << elem
#define PRINT_ONE_COMMA(r, data, elem) BOOST_PP_STRINGIZE(elem) " = " << elem << ", " <<

接下来，一些用于打印的实用程序：

#define LAST(seq) BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)), seq)
#define REST(seq) BOOST_PP_SEQ_SUBSEQ(seq, 0, BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)))

最后，我们可以遍历并打印：

#define PRINT(seq) std::cout << BOOST_PP_SEQ_FOR_EACH(PRINT_ONE_COMMA, _, REST(seq)) PRINT_ONE(LAST(seq)) << '\n';

用法如下：

PRINT((var1)(var2)(var3)) // var1 = 5, var2 = 3, var3 = 7

这是一个活生生的例子。

于 2014-04-09T14:26:55.507 回答
0

如果您使用的是支持 C++11 的编译器或具有 C++03 非标准扩展的编译器：

有两个宏和一个模板：

#include <iostream>

struct None {};

template <typename T>
struct Log
{
    static void write(const char* name, const T& value) {
        std::clog << name << " = " << value << '\n';
    }
};

template<>
struct Log<None>
{
    static void write(const char*, const None&) {}
};

#define LOG_VALUE_DETAIL(A, B, C, D, E, ...) do { \
    Log<decltype(A)>::write(#A, A); \
    Log<decltype(B)>::write(#B, B); \
    Log<decltype(C)>::write(#C, C); \
    Log<decltype(D)>::write(#D, D); \
    Log<decltype(E)>::write(#E, E); \
} while(0)

#define LOG_VALUE(...) LOG_VALUE_DETAIL(__VA_ARGS__, None(), None(), None(), None(), None())

inline int f() { return 3; }

int main()
{

    int a = 0;
    int b = 1;
    int c = 2;
    LOG_VALUE(a, b, c, f());
    return 0;
}
于 2014-04-09T14:50:58.730 回答