logo标签列表

C++预处理器__VA_ARGS__参数数量

c++cc-preprocessorvariadic-macros
130

我在网络上找不到答案的一个简单问题。在可变参数宏中，如何查找参数的数量？如果使用boost预处理器有解决方案，那就没问题了。

如果这有所区别，我正在尝试将不定数目的宏参数转换为boost预处理器序列、列表或数组进行进一步处理。

只是为了明确 - 你是在问关于可变参数宏，而不是用于创建可变参数 C 函数的宏吗？ - anon
2
参数类型是否相同？如果是，并且类型已知，则可以使用复合字面量的标准C解决方案；如果未知，您可以使用__typeof__来使其在某些编译器上工作。 - Christoph
1
由于讨论涉及到 Boost 预处理器序列等内容，因此必须使用 C++（这就是为什么我重新标记了 Q - 但未更改问题标题的原因）...糟糕；我会修复它。 - Jonathan Leffler
@JonathanLeffler 不错，Boost是一个C++库。不过，Boost.Preprocessor可以与C一起使用。据我所知，它使用的所有内容都不特定于C++。 - Justin
相关：https://dev59.com/92gt5IYBdhLWcg3w3xEw#26408195 - Gabriel Staples
12个回答
121

我通常使用这个宏来查找参数的数量：

#define NUMARGS(...)  (sizeof((int[]){__VA_ARGS__})/sizeof(int))

完整示例：

#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#define NUMARGS(...)  (sizeof((int[]){__VA_ARGS__})/sizeof(int))
#define SUM(...)  (sum(NUMARGS(__VA_ARGS__), __VA_ARGS__))

void sum(int numargs, ...);

int main(int argc, char *argv[]) {

    SUM(1);
    SUM(1, 2);
    SUM(1, 2, 3);
    SUM(1, 2, 3, 4);

    return 1;
}

void sum(int numargs, ...) {
    int     total = 0;
    va_list ap;

    printf("sum() called with %d params:", numargs);
    va_start(ap, numargs);
    while (numargs--)
        total += va_arg(ap, int);
    va_end(ap);

    printf(" %d\n", total);

    return;
}

这是完全有效的C99代码。然而它有一个缺点——你不能调用没有参数的SUM()宏，但是GCC有解决方案——在这里查看。

所以在使用GCC时，您需要定义类似于以下的宏：

#define       NUMARGS(...)  (sizeof((int[]){0, ##__VA_ARGS__})/sizeof(int)-1)
#define       SUM(...)  sum(NUMARGS(__VA_ARGS__), ##__VA_ARGS__)

即使参数列表为空，它也能正常工作。

4
UM，这对 OP 来说行不通，他需要 BOOST_PP 的大小，BOOST_PP 在编译时运行。 - Kornel Kisielewicz
5
聪明！在 sizeof(int) != sizeof(void *) 的情况下，它也适用吗？ - Adam Liss
3
像任何宏一样，它在编译时被求值。我不知道Boost是什么，但无论如何都不需要Boost。 - qrdl
4
由于我将 {__VA_ARGS__} 转换为 int[]，因此它只是一个int[]，不考虑 __VA_ARGS__ 的实际内容。 - qrdl
3
优雅的解决方案！适用于VS2017。在VS2017中不需要使用##，因为空的__VA_ARGS__会自动删除任何前面的逗号。 - poby
显示剩余28条评论
110
这实际上取决于编译器，没有任何标准支持此功能。
但是，在这里你有一个宏实现可以进行计数：
#define PP_NARG(...) \
         PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) \
         PP_ARG_N(__VA_ARGS__)
#define PP_ARG_N( \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N
#define PP_RSEQ_N() \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0

/* Some test cases */


PP_NARG(A) -> 1
PP_NARG(A,B) -> 2
PP_NARG(A,B,C) -> 3
PP_NARG(A,B,C,D) -> 4
PP_NARG(A,B,C,D,E) -> 5
PP_NARG(1,2,3,4,5,6,7,8,9,0,
         1,2,3,4,5,6,7,8,9,0,
         1,2,3,4,5,6,7,8,9,0,
         1,2,3,4,5,6,7,8,9,0,
         1,2,3,4,5,6,7,8,9,0,
         1,2,3,4,5,6,7,8,9,0,
         1,2,3) -> 63
但现在已经成为C++0x的标准，而且早该这样做了，因为它可以很好地保护可变参数函数免受损坏的调用（即，在可变参数项之后传递值）。这实际上是一种获取我曾经使用的计数的方法，但我想sizeof也可以工作。 - osirisgothra
4
谢谢！这在我的 Visual Studio 2013 上有效： #define EXPAND(x) x#define PP_ARG_N(_1,_2,_3,_4,_5,_6,_7,_8,_9,N,...) N#define PP_NARG(...) EXPAND(PP_ARG_N(__VA_ARGS__, 9,8,7,6,5,4,3,2,1,0)) - mchiasson
2
PP_NARG（）无法返回0。GET_ARG_COUNT()和Y_TUPLE_SIZE()解决方案可行。 - Petr Skocik
1
PP_NARG()无法返回0并不一定是问题。可以说，由于相同的原因，PP_NARG()应该返回1，就像PP_NARG（，）应该返回2一样。在某些情况下，确实检测到0可能很方便，但解决方案似乎要么不太通用（需要第一个标记可粘贴；这可能或可能不可以，具体取决于您用它做什么），要么是特定于实现的（例如需要gnu的逗号删除粘贴技巧）。 - H Walters
2
重复/相关答案：1）https://dev59.com/92gt5IYBdhLWcg3w3xEw#26408195和2）（这个更容易让我看到最初发生了什么，因为它是一个较短的宏）：https://dev59.com/92gt5IYBdhLWcg3w3xEw#11763277 - Gabriel Staples
显示剩余10条评论
61
如果您使用C++11，并且需要将该值作为C++编译时常量，一个非常优雅的解决方案是：
#include <tuple>

#define MACRO(...) \
    std::cout << "num args: " \
    << std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value \
    << std::endl;
请注意：计数完全在编译时进行，并且该值可以在需要编译时整数的任何地方使用，例如作为std::array的模板参数。
2
很棒的解决方案！与上面建议的 sizeof((int[]){__VA_ARGS__})/sizeof(int) 不同，它甚至在参数无法全部转换为 int 时也能正常工作。 - Wim
2
不支持模板，例如 NUMARGS( sum<1,2> ); 请参见 https://godbolt.org/z/_AAxmL - jorgbrown
1
我认为这实际上可能是一个优点，@jorgbrown，至少在大多数情况下。由于它依赖于编译器而不是预处理器来进行计数，因此它会给出编译器看到的参数数量，这很可能与大多数程序员所期望的相匹配。但是，如果您希望它考虑预处理器的贪婪性，那么它确实会引起麻烦。 - Justin Time - Reinstate Monica
1
如果使用C++，为什么不使用C++的方式来做这件事呢？--template<typename ...T> inline constexpr size_t number_of_args(T ... a) { return sizeof...(a); }-- 这是标准的C++编译时解决方案。适用于C++11及以上版本。核心语言无需 std::。 - Chef Gladiator
遗憾的是，使用std函数或模板需要计算参数是否有效（在语法上定义和格式良好）。当auto blah = tensor_type<float, PP_NARG(batch size, num adj, 2(f0,f1))>(foo, bar);时，PP_NARG(...)解决方案完美地工作。 - imkzh
显示剩余2条评论
30
为方便起见，这里提供了一个适用于0到70个参数的实现，并且在Visual Studio、GCC和Clang中都可以使用。我相信它将适用于Visual Studio 2010及更高版本，但我只在VS2013-2022中进行了测试。
2023年1月更新：我已经测试并确认，在使用/Zc:preprocessor编译器选项时，非Microsoft变体现在可以在Visual Studio 2019/2022中使用，该选项提供了符合C11和C17预处理器标准。您可以使用_MSVC_TRADITIONAL预处理器符号来测试是否正在使用这个新的兼容预处理器（但我还没有更新下面的示例来执行此操作）。
#ifdef _MSC_VER // Microsoft compilers

#   define GET_ARG_COUNT(...)  INTERNAL_EXPAND_ARGS_PRIVATE(INTERNAL_ARGS_AUGMENTER(__VA_ARGS__))

#   define INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
#   define INTERNAL_EXPAND(x) x
#   define INTERNAL_EXPAND_ARGS_PRIVATE(...) INTERNAL_EXPAND(INTERNAL_GET_ARG_COUNT_PRIVATE(__VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
#   define INTERNAL_GET_ARG_COUNT_PRIVATE(_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count

#else // Non-Microsoft compilers

#   define GET_ARG_COUNT(...) INTERNAL_GET_ARG_COUNT_PRIVATE(0, ## __VA_ARGS__, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#   define INTERNAL_GET_ARG_COUNT_PRIVATE(_0, _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count

#endif

static_assert(GET_ARG_COUNT() == 0, "GET_ARG_COUNT() failed for 0 arguments");
static_assert(GET_ARG_COUNT(1) == 1, "GET_ARG_COUNT() failed for 1 argument");
static_assert(GET_ARG_COUNT(1,2) == 2, "GET_ARG_COUNT() failed for 2 arguments");
static_assert(GET_ARG_COUNT(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70) == 70, "GET_ARG_COUNT() failed for 70 arguments");
2
@Vroomfondel，Microsoft的变体确实适用于零参数。上面示例中的第一个static_assert是针对零参数情况的特定测试，我刚在Visual Studio 2017 v15.8.9上编译并运行了它。 - Chris Kline
有趣的是，在非微软编译器上使用微软变量似乎行不通，你知道微软预处理器做了什么不同的事情使代码起作用的相反方式吗？顺便说一下，我尝试过C，而不是C++。 - Vroomfondel
我认为这是因为MSVC对“零长度__VA_ARGS__”更友好一些（在C++中，这在技术上是一个（几乎普遍的，事实上的）编译器扩展，直到C++20）。大多数（全部？）编译器允许零长度，但如果列表为空，则会在尾随逗号上窒息（并将##重载为原型__VA_OPT__，以在这种情况下删除逗号）； MSVC版本的扩展只是不会在逗号上窒息（但会在重载的##上窒息）。将MSVC unused, __VA_ARGS__与非MSVC 0, ## __VA_ARGS__进行比较；两者都没有更正确，问题在于它们不同。 - Justin Time - Reinstate Monica
2
很遗憾，gcc不接受没有扩展名的0个参数：至少必须设置-std = gnu ++ 11选项。 - Andry
“Microsoft variant” 我认为是 cl.exe 在某个任意时刻定义为 C 或 C++ 的语言。如果可能的话，我更喜欢遵循官方 WG14 定义的标准，避免使用 cl.exe。 - Chef Gladiator
显示剩余3条评论
23

有一些C++11的解决方案可以在编译时找到参数的数量，但是我很惊讶地发现没有人建议使用这么简单的方法：

有一些C++11的解决方案可以在编译时找到参数的数量，但是我很惊讶地发现没有人建议使用这么简单的方法：

#define VA_COUNT(...) detail::va_count(__VA_ARGS__)

namespace detail
{
    template<typename ...Args>
    constexpr std::size_t va_count(Args&&...) { return sizeof...(Args); }
}

这也不需要包含<tuple>头文件。

3
为什么不直接使用可变参数模板和sizeof...呢？（就像我自己的回答中所示） C++已经变成了一个庞然大物。它有太多的特性，其中许多特性（如可变参数模板）很少使用。你读一些资料，写一些例子，然后就忘记了。因此，在正确的时间想出正确的解决方案是很困难的。由于你的解决方案似乎比我的更好，所以我会让自然选择发挥作用并删除我的解决方案。 - zdf
3
可以理解，但我经常使用可变参数模板。自从 C++11 以来，我的程序变得更加健壮，这是其中的主要原因之一。不过你不用删除你的回答，我认为这也是一个很好的观点。 - monkey0506
3
VA_COUNT(&,^,%) 这样的写法行不通。如果你要通过函数进行计数，那么使用宏就没有意义。 - Qwertiy
这个解决方案仍然存在一个问题：VA_COUNT的参数都是尚未定义为变量或其他内容的标识符，这会导致错误“***变量未定义”。有没有办法解决这个问题？ - ipid
在标准的 C++ 上下文中，这是正确的答案。不需要宏。https://godbolt.org/z/varbM6r69 - Chef Gladiator
1
@ChefGladiator 我将宏包含在我的答案中，仅是为了与标准变参宏相平行，尽管像 @Qwertiy 指出的那样，它并不涵盖一些更抽象的用例。此外，“在标准C++的情况下”，您可能希望使用C++头文件<cstdlib>和<cassert>，而不是将东西引入全局命名空间的C头文件。 - monkey0506
9

这个在gcc/llvm中不带任何参数就能工作。[链接很蠢]

/*
 * we need a comma at the start for ##_VA_ARGS__ to consume then
 * the arguments are pushed out in such a way that 'cnt' ends up with
 * the right count.  
 */
#define COUNT_ARGS(...) COUNT_ARGS_(,##__VA_ARGS__,6,5,4,3,2,1,0)
#define COUNT_ARGS_(z,a,b,c,d,e,f,cnt,...) cnt

#define C_ASSERT(test) \
    switch(0) {\
      case 0:\
      case test:;\
    }

int main() {
   C_ASSERT(0 ==  COUNT_ARGS());
   C_ASSERT(1 ==  COUNT_ARGS(a));
   C_ASSERT(2 ==  COUNT_ARGS(a,b));
   C_ASSERT(3 ==  COUNT_ARGS(a,b,c));
   C_ASSERT(4 ==  COUNT_ARGS(a,b,c,d));
   C_ASSERT(5 ==  COUNT_ARGS(a,b,c,d,e));
   C_ASSERT(6 ==  COUNT_ARGS(a,b,c,d,e,f));
   return 0;
}

Visual Studio似乎忽略了用于消耗空参的##运算符。您可能可以通过类似以下方式解决此问题：

#define CNT_ COUNT_ARGS
#define PASTE(x,y) PASTE_(x,y)
#define PASTE_(x,y) x ## y
#define CNT(...) PASTE(ARGVS,PASTE(CNT_(__VA_ARGS__),CNT_(1,##__VA_ARGS__)))
//you know its 0 if its 11 or 01
#define ARGVS11 0
#define ARGVS01 0
#define ARGVS12 1
#define ARGVS23 2
#define ARGVS34 3
我测试了在 Visual Studio 2008 中使用 COUNT_ARGS() = 1 的情况，但它并没有起作用。 - user720594
链接似乎已经损坏。 - Jan Smrčina
固定的链接。VS可能在做一些不同寻常的事情:）。我不认为他们会很快完全支持C99。 - user1187902
3
如果__VA_ARGS__为空，则##__VA_ARGS__会吞掉if之前的逗号，这是GCC的一个扩展行为，而不是标准行为。请注意，此处仅进行翻译，不包括任何解释或其他内容。 - anon
如果你使用了“-std=c99”，它将无法与GCC一起工作。 - Kaz
6
我假设每个参数传入__VA_ARGS__都是以逗号分隔的。如果是这样，我认为以下方法可以很干净地实现这一点。
#include <cstring>

constexpr int CountOccurances(const char* str, char c) {
    return str[0] == char(0) ? 0 : (str[0] == c) + CountOccurances(str+1, c);
}

#define NUMARGS(...) (CountOccurances(#__VA_ARGS__, ',') + 1)

int main(){
    static_assert(NUMARGS(hello, world) == 2, ":(")  ;
    return 0;
}

在Godbolt上，这对于clang 4和GCC 5.1都有效。这将在编译时计算，但不会在预处理器中评估。因此，如果您尝试做类似于制作FOR_EACH的事情，那么这是行不通的。

1
这个答案被低估了。它甚至可以处理 NUMARGS(hello, world = 2, ohmy42, !@#$%^&*()-+=) !!! 每个参数字符串中不能有其他符号，如“,”。 - pterodragon
需要进行调整以匹配圆括号，因为 int count = NUMARGS( foo(1, 2) ); 的结果是 2 而不是 1。https://godbolt.org/z/kpBuOm - jorgbrown
这在使用lambda、函数调用或任何可能包含参数中额外逗号的情况下，将无法按预期工作。 - Nandee
6

使用msvc扩展：

#define Y_TUPLE_SIZE(...) Y_TUPLE_SIZE_II((Y_TUPLE_SIZE_PREFIX_ ## __VA_ARGS__ ## _Y_TUPLE_SIZE_POSTFIX,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0))
#define Y_TUPLE_SIZE_II(__args) Y_TUPLE_SIZE_I __args

#define Y_TUPLE_SIZE_PREFIX__Y_TUPLE_SIZE_POSTFIX ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,0

#define Y_TUPLE_SIZE_I(__p0,__p1,__p2,__p3,__p4,__p5,__p6,__p7,__p8,__p9,__p10,__p11,__p12,__p13,__p14,__p15,__p16,__p17,__p18,__p19,__p20,__p21,__p22,__p23,__p24,__p25,__p26,__p27,__p28,__p29,__p30,__p31,__n,...) __n

可处理0至32个参数。此限制可以轻松扩展。

编辑： 简化版本（适用于VS2015 14.0.25431.01 Update 3和gcc 7.4.0），最多复制和粘贴100个参数：

#define COUNTOF(...) _COUNTOF_CAT( _COUNTOF_A, ( 0, ##__VA_ARGS__, 100,\
    99, 98, 97, 96, 95, 94, 93, 92, 91, 90,\
    89, 88, 87, 86, 85, 84, 83, 82, 81, 80,\
    79, 78, 77, 76, 75, 74, 73, 72, 71, 70,\
    69, 68, 67, 66, 65, 64, 63, 62, 61, 60,\
    59, 58, 57, 56, 55, 54, 53, 52, 51, 50,\
    49, 48, 47, 46, 45, 44, 43, 42, 41, 40,\
    39, 38, 37, 36, 35, 34, 33, 32, 31, 30,\
    29, 28, 27, 26, 25, 24, 23, 22, 21, 20,\
    19, 18, 17, 16, 15, 14, 13, 12, 11, 10,\
    9, 8, 7, 6, 5, 4, 3, 2, 1, 0 ) )
#define _COUNTOF_CAT( a, b ) a b
#define _COUNTOF_A( a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,\
    a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,\
    a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,\
    a30, a31, a32, a33, a34, a35, a36, a37, a38, a39,\
    a40, a41, a42, a43, a44, a45, a46, a47, a48, a49,\
    a50, a51, a52, a53, a54, a55, a56, a57, a58, a59,\
    a60, a61, a62, a63, a64, a65, a66, a67, a68, a69,\
    a70, a71, a72, a73, a74, a75, a76, a77, a78, a79,\
    a80, a81, a82, a83, a84, a85, a86, a87, a88, a89,\
    a90, a91, a92, a93, a94, a95, a96, a97, a98, a99,\
    a100, n, ... ) n
4
这是只有我觉得还是违反了代码异味规则吗？ - osirisgothra
在我的基本测试中，它可以在VC++至少到VS2012以及GCC和clang中正常工作。 - ThreeBit
@osirisgothra，为什么它会有异味？ - ceztko
虽然这个宏有广泛的编译器支持，但它不能处理像 Y_TUPLE_SIZE("Hello") 这样的宏参数，使其相当不可行。我同意 @osirisgothra 的观点。 - ceztko
@ceztko，我刚刚在VS2013（版本12.0.21005.1 REL）上进行了测试，它可以工作（但与ThreeBit的说法相反，它似乎无法与GCC 4.8.3一起使用）。 - user45891
1
这个宏可能对你有用，但存在严重的缺陷。我进行了大量研究，并找到了更干净、适用于 GCC 和 VS 的方法。你可以在我的答案中找到它们，那个问题与此类似。 - ceztko
4

以下是一种简单的方法来统计 VA_ARGS 的0个或多个参数，我的示例假设最多有5个变量，但如果需要，您可以添加更多。

#define VA_ARGS_NUM_PRIV(P1, P2, P3, P4, P5, P6, Pn, ...) Pn
#define VA_ARGS_NUM(...) VA_ARGS_NUM_PRIV(-1, ##__VA_ARGS__, 5, 4, 3, 2, 1, 0)


VA_ARGS_NUM()      ==> 0
VA_ARGS_NUM(19)    ==> 1
VA_ARGS_NUM(9, 10) ==> 2
         ...
不幸的是，当VA_ARGS_NUM与宏一起使用时，该方法无法正常工作：如果我有#define TEST（即空的TEST），并且在#if中使用VA_ARGS_NUM(TEST)时不返回0（零）:( - AntonK
@AntonK，您能否发布您所做的具体内容？ - elhadi dp ıpɐɥןǝ
3
我发现这里的答案仍然不完整。我在这里找到的最接近的便携式实现是：C++预处理器__VA_ARGS__参数数量，但在GCC中零参数至少需要-std=gnu++11命令行参数才能工作。因此，我决定将此解决方案与https://gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/合并。请注意，保留了HTML标签。
#define UTILITY_PP_CONCAT_(v1, v2) v1 ## v2
#define UTILITY_PP_CONCAT(v1, v2) UTILITY_PP_CONCAT_(v1, v2)

#define UTILITY_PP_CONCAT5_(_0, _1, _2, _3, _4) _0 ## _1 ## _2 ## _3 ## _4

#define UTILITY_PP_IDENTITY_(x) x
#define UTILITY_PP_IDENTITY(x) UTILITY_PP_IDENTITY_(x)

#define UTILITY_PP_VA_ARGS_(...) __VA_ARGS__
#define UTILITY_PP_VA_ARGS(...) UTILITY_PP_VA_ARGS_(__VA_ARGS__)

#define UTILITY_PP_IDENTITY_VA_ARGS_(x, ...) x, __VA_ARGS__
#define UTILITY_PP_IDENTITY_VA_ARGS(x, ...) UTILITY_PP_IDENTITY_VA_ARGS_(x, __VA_ARGS__)

#define UTILITY_PP_IIF_0(x, ...) __VA_ARGS__
#define UTILITY_PP_IIF_1(x, ...) x
#define UTILITY_PP_IIF(c) UTILITY_PP_CONCAT_(UTILITY_PP_IIF_, c)

#define UTILITY_PP_HAS_COMMA(...) UTILITY_PP_IDENTITY(UTILITY_PP_VA_ARGS_TAIL(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0))
#define UTILITY_PP_IS_EMPTY_TRIGGER_PARENTHESIS_(...) ,

#define UTILITY_PP_IS_EMPTY(...) UTILITY_PP_IS_EMPTY_( \
    /* test if there is just one argument, eventually an empty one */ \
    UTILITY_PP_HAS_COMMA(__VA_ARGS__),                                \
    /* test if _TRIGGER_PARENTHESIS_ together with the argument adds a comma */ \
    UTILITY_PP_HAS_COMMA(UTILITY_PP_IS_EMPTY_TRIGGER_PARENTHESIS_ __VA_ARGS__), \
    /* test if the argument together with a parenthesis adds a comma */ \
    UTILITY_PP_HAS_COMMA(__VA_ARGS__ ()),                             \
    /* test if placing it between _TRIGGER_PARENTHESIS_ and the parenthesis adds a comma */ \
    UTILITY_PP_HAS_COMMA(UTILITY_PP_IS_EMPTY_TRIGGER_PARENTHESIS_ __VA_ARGS__ ()))

#define UTILITY_PP_IS_EMPTY_(_0, _1, _2, _3) UTILITY_PP_HAS_COMMA(UTILITY_PP_CONCAT5_(UTILITY_PP_IS_EMPTY_IS_EMPTY_CASE_, _0, _1, _2, _3))
#define UTILITY_PP_IS_EMPTY_IS_EMPTY_CASE_0001 ,

#define UTILITY_PP_VA_ARGS_SIZE(...) UTILITY_PP_IIF(UTILITY_PP_IS_EMPTY(__VA_ARGS__))(0, UTILITY_PP_VA_ARGS_SIZE_(__VA_ARGS__, UTILITY_PP_VA_ARGS_SEQ64()))
#define UTILITY_PP_VA_ARGS_SIZE_(...) UTILITY_PP_IDENTITY(UTILITY_PP_VA_ARGS_TAIL(__VA_ARGS__))

#define UTILITY_PP_VA_ARGS_TAIL(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14, x, ...) x
#define UTILITY_PP_VA_ARGS_SEQ64() 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0

#define EATER0(...)
#define EATER1(...) ,
#define EATER2(...) (/*empty*/)
#define EATER3(...) (/*empty*/),
#define EATER4(...) EATER1
#define EATER5(...) EATER2
#define MAC0() ()
#define MAC1(x) ()
#define MACV(...) ()
#define MAC2(x,y) whatever

static_assert(UTILITY_PP_VA_ARGS_SIZE() == 0, "1");
static_assert(UTILITY_PP_VA_ARGS_SIZE(/*comment*/) == 0, "2");
static_assert(UTILITY_PP_VA_ARGS_SIZE(a) == 1, "3");
static_assert(UTILITY_PP_VA_ARGS_SIZE(a, b) == 2, "4");
static_assert(UTILITY_PP_VA_ARGS_SIZE(a, b, c) == 3, "5");
static_assert(UTILITY_PP_VA_ARGS_SIZE(a, b, c, d) == 4, "6");
static_assert(UTILITY_PP_VA_ARGS_SIZE(a, b, c, d, e) == 5, "7");
static_assert(UTILITY_PP_VA_ARGS_SIZE((void)) == 1, "8");
static_assert(UTILITY_PP_VA_ARGS_SIZE((void), b, c, d) == 4, "9");
static_assert(UTILITY_PP_VA_ARGS_SIZE(UTILITY_PP_IS_EMPTY_TRIGGER_PARENTHESIS_) == 1, "10");
static_assert(UTILITY_PP_VA_ARGS_SIZE(EATER0) == 1, "11");
static_assert(UTILITY_PP_VA_ARGS_SIZE(EATER1) == 1, "12");
static_assert(UTILITY_PP_VA_ARGS_SIZE(EATER2) == 1, "13");
static_assert(UTILITY_PP_VA_ARGS_SIZE(EATER3) == 1, "14");
static_assert(UTILITY_PP_VA_ARGS_SIZE(EATER4) == 1, "15");
static_assert(UTILITY_PP_VA_ARGS_SIZE(MAC0) == 1, "16");
// a warning in msvc
static_assert(UTILITY_PP_VA_ARGS_SIZE(MAC1) == 1, "17");
static_assert(UTILITY_PP_VA_ARGS_SIZE(MACV) == 1, "18");
// This one will fail because MAC2 is not called correctly
//static_assert(UTILITY_PP_VA_ARGS_SIZE(MAC2) == 1, "19");

https://godbolt.org/z/3idaKd

  • c++11，msvc 2015，gcc 4.7.1和clang 3.0都是与C++11标准兼容的编译器版本。
最初的回答
感谢指出 GNU 标准。它解决了我的问题 :D，不像其他答案... - Berthin
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接