重载带有可变参数的宏

Overloading macros with variadic arguments

本文关键字：参数 变参 重载      更新时间：2023-10-16

我正在尝试构建一个宏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, ...);

如果参数计数已知，那么关于宏的"重载"有各种答案；然而，他们确定__VA_ARGS__长度的方法都只适用于有限的、选定的数量。

有什么技巧可以让类似的方法适用于我的"一个论点/多个论点"案例吗？

注：

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

简单。我们只是做了一点探索，看看令牌是否是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)...)
    {}
};
相关文章：