Question

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

例如：

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];}}

Answer 1

#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时包含的任何间距（或不存在）都将在输出中进行镜像。

Answer 2

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

Answer 3

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

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

 void function_taking_varargs(...);

 #define SLIGHTLY_BETTER(x) \
      function_taking_varargs x


 SLIGHTLY_BETTER((a, b, c));

Answer 4

这个在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

这里是live example。

Answer 5

如果您使用的是支持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;
}

如何用宏打印可变数量的参数？

5 个答案: