c++ - 使用可变参数重载宏

Question

我正在尝试构建一个宏M，它将扩展为两种可能性之一，具体取决于它是否具有一个或多个参数:

M(x)

应该扩展到

f(x)

同时

M(x, "%d%d%d", 1, 2, 3)

应该扩展到

g(x, "%d%d%d", 1, 2, 3)

函数签名在哪里

f(int x);
g(int x, const char *fmt, ...);

有various answers如果参数计数已知，则关于宏的“重载”；然而，他们确定 __VA_ARGS__ 长度的方法都只适用于有限的选定数字。

是否有任何技巧可以使类似的方法适用于我的“一个参数/多个参数”的情况？

注意:

重载函数不是一个选项，因为在我的例子中，它们实际上是两个不同类的构造函数。

Answer 1

简单。我们只是做一点探测来确定 token 是否为 1:

#define CAT(a, ...) PRIMITIVE_CAT(a, __VA_ARGS__)
#define PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__

#define CHECK_N(x, n, ...) n
#define CHECK(...) CHECK_N(__VA_ARGS__, 0,)
#define PROBE(x) x, 1,

#define IS_1(x) CHECK(PRIMITIVE_CAT(IS_1_, x))
#define IS_1_1 PROBE(~)

因此，如果 token 是 1，则 IS_1 扩展为 1，否则扩展为 0。那么接下来，计算参数的数量(最多 8 个):

#define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
#define NARGS(...) NARGS_SEQ(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1)

然后重载它是否等于1:

#define M_1 f
#define M_0 g

#define M(...) CAT(M_, IS_1(NARGS(__VA_ARGS__)))(__VA_ARGS__)

那么你可以像这样调用M:

M(x) // Expands to f(x)
M(x, "%d%d%d", 1, 2, 3) // Expands to g(x, "%d%d%d", 1, 2, 3)

现在，对于标准 C 预处理器(gcc 最多可以计算 32767 个参数)，您最多只能计算 64 个参数(我的示例最多计算 8 个)。如果你需要有更多的参数，最好使用一个没有限制的序列。因此，首先编写一个方法，使用序列迭代将序列转换回参数:

#define TO_ARGS(seq) TO_ARGS_END(TO_ARGS_1 seq)
#define TO_ARGS_END(...) TO_ARGS_END_I(__VA_ARGS__)
#define TO_ARGS_END_I(...) __VA_ARGS__ ## _END
#define TO_ARGS_1(x) x TO_ARGS_2  
#define TO_ARGS_2(x) , x TO_ARGS_3  
#define TO_ARGS_3(x) , x TO_ARGS_2  
#define TO_ARGS_1_END
#define TO_ARGS_2_END
#define TO_ARGS_3_END

接下来定义 M 宏来重载序列中是否有一个元素:

#define IS_PAREN(x) CHECK(IS_PAREN_PROBE x)
#define IS_PAREN_PROBE(...) PROBE(~)

#define EAT(...)

#define M_1(seq) g(TO_ARGS(seq))
#define M_0(seq) f(TO_ARGS(seq))

#define M(seq) CAT(M_, IS_PAREN(EAT seq))(seq)

然后你可以这样调用它:

M((x)) // Expands to f(x)
M((x)("%d%d%d")(1)(2)(3)) // Expands to g(x, "%d%d%d", 1, 2, 3)

当然，在 C++14 中，如果您不需要源信息，那么您可以使用可变参数模板:

template<class T>
auto M(T&& xs) -> decltype(f(std::forward<T>(x)))
{
    return f(std::forward<T>(x));
}

template<class T, class U, class... Ts>
auto M(T&& x, U&& y, Ts&&... xs) -> decltype(g(std::forward<T>(x), std::forward<U>(y), std::forward<Ts>(xs)...))
{
    return g(std::forward<T>(x), std::forward<U>(y),std::forward<Ts>(xs)...);
}

或者对于构造函数:

class M : f, g
{
    template<class T>
    M(T&& xs) : f(std::forward<T>(x))
    {}

    template<class T, class U, class... Ts>
    M(T&& x, U&& y, Ts&&... xs) : g(std::forward<T>(x), std::forward<U>(y), std::forward<Ts>(xs)...)
    {}
};