C preprocessor VA ARGS number of arguments

Question

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

User · Answer

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    define VA COUNT      detail  va count   VA ARGS     namespace detail       template lt typename    Args gt      constexpr std  size t va count Args amp  amp        return sizeof    Args         This doesn t require inclusion of the  lt tuple gt  header either

User · Answer

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    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           gt  0 VA ARGS NUM 19        gt  1 VA ARGS NUM 9  10     gt  2

User · Answer

If you are using C  11  and you need the value as a C   compile-time constant  a very elegant solution is this    include  lt tuple gt    define MACRO            std  cout  lt  lt   num args           lt  lt  std  tuple size lt decltype std  make tuple   VA ARGS     gt   value        lt  lt  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

User · Answer

I m assuming that each argument to VA ARGS will be comma separated  If so I think this should work as a pretty clean way to do this    include  lt cstring gt   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

User · Answer

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         amp  amp  args i                       i            break                      i                      i         return result      define MACRO              int count   countArgs    VA ARGS         printf  NUM ARGS   d n  count

User · Answer

this works with 0 arguments with gcc llvm    links are dumb         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    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

User · Answer

With msvc extension   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  EDIT  Simplified version  works in VS2015 14 0 25431 01 Update 3  amp  gcc 7 4 0  up to 100 arguments to copy  amp  paste   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

User · Answer

I usually use this macro to find a number of params    define NUMARGS        sizeof  int      VA ARGS     sizeof int     Full example    include  lt stdio h gt   include  lt string h gt   include  lt stdarg h gt    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   So in case of GCC you need to define macros like this    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

User · Answer

This is actually compiler dependent  and not supported by any standard   Here however you have a macro implementation that 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  - gt  1 PP NARG A B  - gt  2 PP NARG A B C  - gt  3 PP NARG A B C D  - gt  4 PP NARG A B C D E  - gt  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  - gt  63

User · Answer

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

User · Answer

I ve found answers here still are incomplete   The most closest portable implementation I ve found from here is   C   preprocessor   VA ARGS   number of arguments  But it doen t work with the zero arguments in the GCC without at least -std gnu  11 command line parameter   So I decided to merge this solution with that  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  11  msvc 2015  gcc 4 7 1  clang 3 0

User · Answer

Boost Preprocessor actually has this as of Boost 1 49  as BOOST PP VARIADIC SIZE       It works up to size 64   Under the hood  it s basically the same as Kornel Kisielewicz s answer

[c++] C++ preprocessor __VA_ARGS__ number of arguments

Examples related to c++

Examples related to c

Examples related to c-preprocessor

Examples related to variadic-macros