Welcome to Software Development on Codidact!

Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.

Post History

50%

+0 −0

Q&A 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 wit...

posted 3h ago by Lundin‭ · edited 1h ago by Lundin‭

Answer

#2: Post edited by

Lundin‭ · 2025-06-09T17:19:32Z (about 1 hour ago)

Copy Link

Raw

Markdown

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, if keep in mind that only the right-most operand of a chain of comma operators results in a value.~~
~~- The C23 `__VA_OPT__` feature which only evaluates its argument if there were variadic arguments passed.~~
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.
Example:
```c
#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:
```text
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.

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:
```c
#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:
```text
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.

#1: Initial revision by

Lundin‭ · 2025-06-09T14:44:59Z (about 3 hours ago)

Copy Link

Raw

Markdown

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, if keep in mind that only the right-most operand of a chain of comma operators results in a value.
- The C23 `__VA_OPT__` feature which only evaluates its argument if there were variadic arguments passed. 

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.

Example:

```c
#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:

```text
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.

Communities

Post History