Macro to count the number of arguments

The least bad version (as per C23) I can think of is to do the usual trick with counting macros - have a macro call another macro until you run out of variadic arguments.

We can implement that with:

• The comma operator, keeping in mind that only the right-most operand in a chain of comma operators results in a value; the rest are discarded.
• The C23 __VA_OPT__ feature which only evaluates its argument if there were variadic arguments passed to the macro where it is present.

And so:

 #define COUNT(...) ( 0 __VA_OPT__(COUNT1(__VA_ARGS__)) )

Where 0 is the value we get if there are no variadic arguments. Otherwise the macro COUNT1 is evaluated:

 #define COUNT1(arg, ...) ,1 __VA_OPT__(COUNT2(__VA_ARGS__))

And there the comma operator comes into play - if we have exactly one argument we'd now pre-process this into (0,1) which gives the value 1 and is an integer constant expression evaluated at compile-time. We can keep building this as (0, 1, 2, 3) and so on, where the expression always evaluates to the the right-most operand.

Example:

#include <stdio.h>

#define COUNT4(arg, ...) ,4
#define COUNT3(arg, ...) ,3 __VA_OPT__(COUNT4(__VA_ARGS__))
#define COUNT2(arg, ...) ,2 __VA_OPT__(COUNT3(__VA_ARGS__))
#define COUNT1(arg, ...) ,1 __VA_OPT__(COUNT2(__VA_ARGS__))
#define COUNT(...) ( 0 __VA_OPT__(COUNT1(__VA_ARGS__)) )

int main(void)
{
  printf("%d\n", COUNT());
  printf("%d\n", COUNT(hi));
  printf("%d\n", COUNT(hi, there));
  printf("%d\n", COUNT(hi, there, 123));
  printf("%d\n", COUNT(1, hello, world, "test"));
}

Output:

0
1
2
3
4

The advantage of this is that it counts true pp-tokens with no care about what type etc those are. It also supports an empty argument list. The disadvantage is that we have to set an upper limit (10 or so) of arguments that we accept.

posted about 3 hours ago

CC BY-SA 4.0

39m ago

Lundin‭

9444 reputation 41 129 1091 178

If you are on C++11 (or newer), it should be possible to use variadic templates to write a simple (compile-time) function to count the number of arguments:

template<typename... Ts>
constexpr int countArgs(const Ts&... args) {
    return sizeof...(args);
}

With this function, we can go ahead and write the desired macro as follows:

#define F(...) f(countArgs(__VA_ARGS__), __VA_ARGS__)

This should work no matter what the types of the variadic arguments are.

posted about 7 hours ago

CC BY-SA 4.0

mr Tsjolder‭

544 reputation 6 17 62 6