使用可变参数重载宏

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, ...);

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

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

注意：

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

Answer 1

简单。我们只是做一点探测来确定令牌是否为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(~)

如果令牌是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)...)
    {}
};