C++ 预处理器 __VA_ARGS__ 参数数量
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/2124339/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
C++ preprocessor __VA_ARGS__ number of arguments
提问by Anycorn
Simple question for which I could not find answer on the net. In variadic argument macros, how to find the number of arguments? I am okay with boost preprocessor, if it has the solution.
我在网上找不到答案的简单问题。在可变参数宏中，如何找到参数的数量？我对 boost 预处理器没问题，如果它有解决方案的话。
If it makes a difference, I am trying to convert variable number of macro arguments to boost preprocessor sequence, list, or array for further reprocessing.
如果它有所作为，我正在尝试将可变数量的宏参数转换为增强预处理器序列、列表或数组，以便进一步重新处理。
采纳答案by Kornel Kisielewicz
This is actually compiler dependent, and not supported by any standard.
这实际上取决于编译器，不受任何标准支持。
Here however you have a macro implementationthat does the count:
但是，在这里您有一个可以进行计数的宏实现：
#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
回答by qrdl
I usually use this macro to find a number of params:
我通常使用这个宏来查找一些参数：
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))
Full example:
完整示例：
#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;
}
It is completely valid C99 code. It has one drawback, though - you cannot invoke the macro SUM()without params, but GCC has a solution to it - see here.
它是完全有效的 C99 代码。不过，它有一个缺点——你不能在SUM()没有参数的情况下调用宏，但 GCC 有一个解决方案——见这里。
So in case of GCC you need to define macros like this:
因此，在 GCC 的情况下，您需要像这样定义宏：
#define NUMARGS(...) (sizeof((int[]){0, ##__VA_ARGS__})/sizeof(int)-1)
#define SUM(...) sum(NUMARGS(__VA_ARGS__), ##__VA_ARGS__)
and it will work even with empty parameter list
即使参数列表为空，它也能工作
回答by maciek gajewski
If you are using C++11, and you need the value as a C++ compile-time constant, a very elegant solution is this:
如果您使用的是 C++11，并且需要将该值作为 C++ 编译时常量，那么一个非常优雅的解决方案是：
#include <tuple>
#define MACRO(...) \
std::cout << "num args: " \
<< std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value \
<< std::endl;
Please note: the counting happens entirely at compile time, and the value can be used whenever compile-time integer is required, for instance as a template parameter to std::array.
请注意：计数完全发生在编译时，只要需要编译时整数，就可以使用该值，例如作为 std::array 的模板参数。
回答by Chris Kline
For convenience, here's an implementation that works for 0 to 70 arguments, and works in Visual Studio, GCC, and Clang. I believe it will work in Visual Studio 2010 and later, but have only tested it in VS2013.
为方便起见，这里有一个适用于 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");
回答by monkey0506
There are some C++11 solutions for finding the number of arguments at compile-time, but I'm surprised to see that no one has suggested anything so simple as:
有一些 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); }
}
This doesn't require inclusion of the <tuple>header either.
这也不需要包含<tuple>标题。
回答by user1187902
this works with 0 arguments with gcc/llvm. [links are dumb]
这适用于 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 seems to be ignoring the ## operator used to consume the empty argument. You can probably get around that with something like
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
回答by user720594
With msvc extension:
使用 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
Works for 0 - 32 arguments. This limit can be easily extended.
适用于 0 - 32 个参数。这个限制可以很容易地扩展。
回答by matanmarkind
I'm assuming that each argument to VA_ARGSwill be comma separated. If so I think this should work as a pretty clean way to do this.
我假设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;
}
Worked for me on godbolt for clang 4 and GCC 5.1. This will compute at compile time, but won't evaluate for the preprocessor. So if you are trying to do something like making a FOR_EACH, then this won't work.
为我在 godbolt 上为 clang 4 和 GCC 5.1 工作。这将在编译时计算，但不会对预处理器进行评估。因此，如果您尝试执行诸如FOR_EACH 之类的操作，那么这将不起作用。
回答by elhadi dp ?p????
herein a simple way to count 0 or more arguments of VA_ARGS, my exemple assumes a maximum of 5 variables, but you can add more if you want.
这里是一种计算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
...
回答by Carlos Leite
You can stringfy and count tokens:
您可以对令牌进行字符串化和计数：
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); \
}
