Préprocesseur C++ __VA_ARGS__ nombre d'arguments
Question simple pour laquelle je n'ai pas trouvé de réponse sur le net. Dans les macros d’arguments variadiques, comment trouver le nombre d’arguments? Je suis d'accord avec le pré-processeur boost, s'il dispose de la solution.
Si cela fait une différence, j'essaie de convertir un nombre variable d'arguments de macro pour améliorer la séquence, la liste ou le tableau du préprocesseur en vue d'un nouveau traitement.
Cela dépend en fait du compilateur et n'est pris en charge par aucun standard.
Ici cependant, vous avez une implémentation macro qui compte:
#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
J'utilise habituellement cette macro pour trouver un certain nombre de paramètres:
#define NUMARGS(...) (sizeof((int[]){__VA_ARGS__})/sizeof(int))
Exemple complet:
#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;
}
C'est complètement valide code C99. Cependant, il a un inconvénient - vous ne pouvez pas appeler la macro SUM() sans paramètres, mais GCC a une solution - voir ici .
Donc, dans le cas de GCC, vous devez définir des macros comme ceci:
#define NUMARGS(...) (sizeof((int[]){0, ##__VA_ARGS__})/sizeof(int)-1)
#define SUM(...) sum(NUMARGS(__VA_ARGS__), ##__VA_ARGS__)
et cela fonctionnera même avec une liste de paramètres vide
Si vous utilisez C++ 11 et que vous avez besoin de la valeur en tant que constante de compilation C++, voici une solution très élégante:
#include <Tuple>
#define MACRO(...) \
std::cout << "num args: " \
<< std::Tuple_size<decltype(std::make_Tuple(__VA_ARGS__))>::value \
<< std::endl;
Remarque: le comptage se fait entièrement au moment de la compilation et la valeur peut être utilisée chaque fois qu'un entier au moment de la compilation est requis, par exemple comme paramètre de modèle pour std :: array.
Pour plus de commodité, voici une implémentation qui fonctionne pour 0 à 70 arguments et fonctionne dans Visual Studio, GCC et Clang . Je pense que cela fonctionnera dans Visual Studio 2010 et versions ultérieures, mais je ne l’ai testé que dans 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");
Avec l'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
Fonctionne pour 0 à 32 arguments. Cette limite peut être facilement étendue.
Il existe certaines solutions C++ 11 pour trouver le nombre d'arguments lors de la compilation, mais je suis surpris de voir que personne n'a suggéré quelque chose d'aussi simple:
#define VA_COUNT(...) detail::va_count(__VA_ARGS__)
namespace detail
{
template<typename ...Args>
constexpr std::size_t va_count(Args&&...) { return sizeof...(Args); }
}
Cela ne nécessite pas l'inclusion de l'en-tête <Tuple> non plus.
cela fonctionne avec 0 argument avec gcc/llvm. [les liens sont muets]
/*
* 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 semble ignorer l'opérateur ## utilisé pour utiliser l'argument vide. Vous pouvez probablement contourner cela avec quelque chose comme
#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
Je suppose que chaque argument de VA_ARGS sera séparé par une virgule. Si c'est le cas, je pense que cela devrait fonctionner comme un moyen assez propre de le faire.
#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;
}
Travaillé pour moi sur godbolt pour Clang 4 et GCC 5.1. Ceci calculera au moment de la compilation, mais ne sera pas évalué pour le préprocesseur. Donc, si vous essayez de faire quelque chose comme faire un FOR_EACH , cela ne fonctionnera pas.
ici, un moyen simple de compter 0 ou plusieurs arguments de VA_ARGS , mon exemple suppose un maximum de 5 variables, mais vous pouvez en ajouter davantage si vous le souhaitez.
#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
...
Le préprocesseur de Boost a en fait cette valeur depuis Boost 1.49, sous la forme BOOST_PP_VARIADIC_SIZE(...) . Cela fonctionne jusqu'à la taille 64.
Sous le capot, c'est fondamentalement la même chose que la réponse de Kornel Kisielewicz .
Vous pouvez stringfy et compter les jetons:
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); \
}