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


99

我在网上找不到答案的简单问题。在可变参数宏中,如何找到参数个数?如果可以的话,我对Boost预处理器还可以。

如果有什么不同,我试图将可变数量的宏参数转换为增强预处理程序序列,列表或数组,以进行进一步的处理。


只是要清楚一点-您是在问可变参数宏,而不是用于创建可变C函数的宏吗?

2
是相同类型的参数吗?如果是这样,并且类型已知,则可以通过复合文字实现标准的C解决方案;如果未知,则可以使用__typeof__它至少在某些编译器上起作用
Christoph 2010年

1
由于讨论是关于Boost预处理程序序列等的,因此它必须是C ++(这就是为什么我重新标记了Q-但是未能更改问题标题)...糟糕!我会解决的。
乔纳森·莱夫勒

@JonathanLeffler是的,Boost是一个C ++库。但是,Boost.Preprocessor可以与C. AFAIK一起使用,它使用的仅是C ++专有的。
贾斯汀

Answers:


90

这实际上取决于编译器,并且不受任何标准支持。

但是,在这里,您可以执行一个宏实现

#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 2014年

答案链接到另一个站点。同样,该链接似乎没有指向正确的答案。即使我设法找到了预期的答案,它似乎也很糟糕,因为它嵌入了将被编译的硬编码“ -1”。有更好的方法。
ceztko 2014年

2
谢谢!这对我来说在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 2015年

1
PP_NARG()无法返回0。GET_ARG_COUNT()Y_TUPLE_SIZE()解决方案起作用。
PSkocik

1
PP_NARG()未能返回0” ...不一定是问题。可以说,PP_NARG() 应该出于同样的原因返回1,PP_NARG(,)应该返回2. 检测 0可能确实是方便在某些情况下,但解决方案似乎既不太普遍(要求第一令牌是pasteable;这可能未必会好起来取决于您使用它的目的)或特定于实现的内容(例如需要使用gnu的逗号删除粘贴技巧)。
H Walters

100

我通常使用此宏来查找许多参数:

#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的大小,该大小必须在编译时运行。
Kornel Kisielewicz

5
聪明!它在sizeof(int) != sizeof(void *)什么时候也起作用?
亚当·利斯

3
@Kornel与任何宏一样,它在编译时进行评估。我不了解Boost,但无论如何都不需要Boost。
qrdl 2010年

4
@Adam因为我强制转换{__VA_ARGS__}int[],所以int[]__VA_ARGS__
qrdl 2010年

3
优雅的解决方案!在VS2017中工作。在##不需要在VS2017作为空__VA_ARGS__将自动删除任何前述逗号。
Poby

37

如果您使用的是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
2016年

同意 很好的解决方案!++。
davernator

不适用于模板,即NUMARGS(sum <1,2>); 参见godbolt.org/z/_AAxmL
jorgbrown

1
我... 至少在大多数情况下,@ jorgbrown 可能实际上是支持它的观点。由于它依靠编译器而不是预处理器进行计数,因此它给出了编译器看到的参数数量,这很可能与大多数程序员所期望的相匹配。但是,如果您希望它考虑到预处理器的贪婪程度,则会造成麻烦。
贾斯汀时间-恢复莫妮卡

极好的答案。您可以将其放入宏#define NUM_ARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
Richard Whitehead

23

为了方便起见,这是一个适用于0到70个参数的实现,并且可以在Visual Studio,GCC和Clang中使用。我相信它可以在Visual Studio 2010及更高版本中使用,但仅在VS2013中进行了测试。

#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");

恕我直言,Microsoft变体无法使用零参数。
Vroomfondel

@Vroomfondel Microsoft变体确实适用于零参数。上面示例中的第一个static_assert是针对零参数情况的特定测试,我刚刚在Visual Studio 2017 v15.8.9上对其进行了编译和运行。
克里斯·克莱恩

有趣的是-在非Microsoft编译器上使用Microsoft变体不起作用-您知道M $预处理程序以不同的方式使代码以相反的方式工作吗?顺便说一句,我尝试了C,而不是C ++。
Vroomfondel

我相信这是因为MSVC对“零长度__VA_ARGS__”(在C ++中,从技术上来说,是(几乎通用的,事实上的标准)编译器扩展,直到C ++ 20)更好一些。大多数(全部?)编译器都允许零长度,但如果列表空(在此情况下以过载##作为原型__VA_OPT__,则以逗号结尾)会阻塞尾随逗号。MSVC的扩展版本不会使逗号窒息(但因重载而窒息##)。比较MSVC unused, __VA_ARGS__与非MSVC 0, ## __VA_ARGS__;两者都不是更正确的,问题在于它们是不同的。
贾斯汀时间-恢复莫妮卡

我不确定在C中是否也一样,@ Vroomfondel,因为我将书签丢失了到最新的草稿。
贾斯汀时间-恢复莫妮卡

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>标头。


1
“但是为什么不仅仅使用可变参数的模板和sizeof ...代替(就像我自己的回答一样)” c ++已成为怪物。它具有太多功能,很少使用诸如可变参数模板之类的功能。您读了一下,写了一些示例,然后忘记了。因此,很难在正确的时间提出正确的想法。由于您的解决方案似乎比我的解决方案更好,因此我将让自然选择生效,然后删除我的解决方案。
zdf

1
@ZDF是可以理解的,但是我碰巧经常使用可变参数模板。自C ++ 11起,我的程序就变得更加健壮,这就是为什么这样做的主要原因之一。我认为不需要删除答案。
monkey0506

1
不能与smth一起使用VA_COUNT(&,^,%)。另外,如果您通过功能进行计数,则在创建宏时没有任何意义。
Qwertiy

这个解决方案仍然是一个问题:VA_COUNT的参数是所有尚未定义为变量或某些内容的标识符,并且会导致错误“ ***变量未定义”。有没有什么办法解决这一问题?
ipid,

7

这适用于gcc / llvm的0参数。[链接很蠢]

/*
 * 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和它没有工作0参数COUNT_ARGS()= 1
user720594

链接似乎断开了。
JanSmrčina16年

固定链接。VS必须像往常一样做一些不同的事情:)。我认为他们不会在不久的将来完全支持C99。
user1187902 '02

2
嗯,##__VA_ARGS____VA_ARGS__GCC扩展名之前(如果为空)吃逗号。这不是标准行为。
基金莫妮卡的诉讼

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 2014年

在我的基本测试中,它至少适用于VC2012以及更高版本的VC ++,对我也适用。
ThreeBit

@osirisgothra,到底为什么会闻到?
ceztko 2014年

尽管此宏具有广泛的编译器支持,但它不适用于像字符串这样的宏参数Y_TUPLE_SIZE("Hello"),从而使其变得不可行。我同意@osirisgothra。
ceztko 2014年

1
该宏可以为您工作,但存在严重缺陷。我做了很多研究,发现更清洁的方法可以在GCC和VS中使用。您可以在我对类似问题的回答中找到它们。
ceztko

3

我假设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;
}

为我工作了clang 4和GCC 5.1的Godbolt。这将在编译时进行计算,但不会评估预处理器。因此,如果您尝试执行类似FOR_EACH的操作,则此操作将无效。


这个答案被低估了。它甚至可以工作NUMARGS(hello, world = 2, ohmy42, !@#$%^&*()-+=)!每个ARG字符串不能有一些其他符号一样',',虽然
pterodragon

需要调整括号,因为int count = NUMARGS( foo(1, 2) );会产生2而不是 1。godbolt.org/z/kpBuOm
jorgbrown

对于lambda,函数调用或任何其他可能在参数中包含逗号的项目,此操作将无法正常工作。
南迪

2

这里是一种简单的方法来计算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(即empty TEST)并且VA_ARGS_NUM(TEST)#if:(
AntonK,

@AntonK能否请您发布您所做的工作?
elhadi dpıpɐɥןǝ18年

0

您可以stringfy和计数令牌:

int countArgs(char *args)
{
  int result = 0;
  int i = 0;

  while(isspace(args[i])) ++i;
  if(args[i]) ++result;

  while(args[i]) {
    if(args[i]==',') ++result;
    else if(args[i]=='\'') i+=2;
    else if(args[i]=='\"') {
      while(args[i]) {
        if(args[i+1]=='\"' && args[i]!='\\') {
          ++i;
          break;
        }
        ++i;
      }
    }
    ++i;
  }

  return result;
}

#define MACRO(...) \
{ \
  int count = countArgs(#__VA_ARGS__); \
  printf("NUM ARGS: %d\n",count); \
}

2
刚刚查看了有关此答案的修改-看来您可能有两个帐户。如果您坚持一个,就可以编辑自己的帖子而无需批准。
J理查德·斯内普


0

我发现这里的答案仍然不完整。

我从这里找到的最接近的可移植实现是: C ++预处理器__VA_ARGS__参数数量

但是,至少在没有-std=gnu++11命令行参数的情况下,它不适用于GCC中的零参数。

因此,我决定将此解决方案与之合并:https : //gustedt.wordpress.com/2010/06/08/detect-empty-macro-arguments/

#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++11msvc 2015gcc 4.7.1clang 3.0
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.