Exclusive to C
[Update 2022 Feb]
If you ask any C expert, <stdarg.h>
is actually to be avoided. The key problem is that the stdarg.h APIs, are imposing on the user the requirement to “tell” explicitly the length of the arguments list, use a sentinel for the last argument or have special logic like printf(const char *, ...)
; printf is “simply” peeking into the first argument to decide on the number of arguments required.
However, using variadic macros in C, you do not need to use stdarg.h (always). How?
Combine standard variadic macro with a function call.
Basically, a macro that expands its arguments to a function call. Calling a function with a special function signature.
1 2 3 |
// required function signature pseudo code // T means any Type void function ( size_t size_, T array_[ static size_] ) |
We simply receive the arrays size and the array, instead of fiddling with “va macros” from the <stdarg.h>
. In the native array, all elements are of the same type.
And through the magic of variadic macro, we make the whole, kind-of-a comfortable. Here is the one I prepared earlier.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// ------------------------------------------------------- // (c) dbj at dbj dot org // CC BY SA 4.0 // https://dbj.org/licesense_dbj // // variadic macro expanding a call to // void function ( size_t size_, T array_[ static size_] ) // #define VARICALL(cb_,T,...) \ cb_( \ sizeof((T[]){__VA_ARGS__}) / sizeof(T) ,\ (T[]){__VA_ARGS__} \ ) |
VARICALL
is deliberately not short and a bit annoying name. So you remember it is a macro. If that is all totally confusing here is my explanation. This is standard C. C++ can not do compound literals. Standard C compound literal is used to declare arrays inline. Thus doing this (only inside some function please) :
1 |
VARICALL(funcint,int,1,2,3); |
Will expand into:
1 2 3 4 5 6 7 |
funcint( // sizeof array declared inline using the compound array literal sizeof((int[]){1,2,3}) / sizeof(int), // second arg is array itself, again using the compound literal // on expanded macro variadic paremeters (int[]){1,2,3} ) ; |
Where that funcint
is declared as:
1 |
void funcint(size_t size_ , int p[static size_]) ; |
Yes, that is legal standard C, array argument declaration, requiring at least size_
elements. And that usage line:
1 2 |
// call the funcint with array of three int's VARICALL(funcint,int,1,2,3); |
Is all you need. #include <stdarg.h>
not required. And of course, Godbolt is ready for you.
For a reasonably large number of use cases, I think that is a very useful little idiom.
[The original article: 27 Feb 2018]
Dealing with a variable number of arguments is pretty easy in C++. Alas in real life, you will need to dive into C, from time to time. And possibly meet C/C++ macros with a variable number of arguments, or even worse sounding “Variadic Macro’s“. But why would anybody need any of this?
Like C++ is not “hard enough” already, one might exclaim? Well, standard C++ is not that hard. But to learn anything properly, good examples are priceless. Here is perhaps one good example aka “use case” where one can deploy variadic macros.
(In case you are in a hurry, Godbolt is here)
Sooner or later you realize your C code will be full of malloc()
calls. It is extremely important to get into the habit of free()
ing, anything that should be freed. Just free-free-free, as much as you can. Being “foolishly” involved with standard C too, I have developed my little function to “free in bulk”. Next is the why and the test code.
First here is some heap-allocated data, that requires a lot of free()
calls afterward.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// note: this is C enum { newlen = 1024, ARRSZ = 9 } ; // global space typedef char * arr_type[ARRSZ] ; // in some function // static array of 9 pointers to the heap space arr_type slave = { calloc( newlen, sizeof(char)), /* 0 */ calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)), calloc( newlen, sizeof(char)) /* 8 */ }; |
In C there are no destructors, so you better be sure you have cleaned up after yourself. A good example is code like the above, with a mandatory, long, and tedious sequence of calls to the standard function free()
that has to come after it :
1 2 3 4 5 |
// you must call free on everything // you have allocated before free( slave[0] ); free( slave[1] ); free( slave[2] ); free( slave[3] ); free( slave[4] ); free( slave[5] ); free( slave[6] ); free( slave[7] ); free( slave[8] ); |
This is not very nice. And more importantly, that is a bit tiresome. So, I have developed a variadic function with a signature like this:
1 2 3 4 5 |
/* NOTE: must place NULL as the last arg! max allowed args is 255 */ void free_free_set_them_free(void * vp, ...); |
And, I have developed a variadic macro with a normal name to use this useful function:
1 2 3 |
// variadic macro #define FREE(...) \ free_free_set_them_free(__VA_ARGS__) |
That syntax is simple. As is the usage standard inbuilt predefined __VA_ARGS__
that will become the arguments list expanded. Now I can ease (a bit), the burden of repeated free calls:
1 2 3 4 5 6 |
FREE( slave[0], slave[1], slave[2], slave[3], slave[4], slave[5], slave[6], slave[7], slave[8], NULL /* do not ever forget NULL as last argument! */ ); |
But. Dear CLANG (aka LVVM) in its standard C reincarnation screams at me now:
1 2 3 4 5 |
warning: passing 'const char *' to parameter of type 'void *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers] free_free_set_them_free(r1,r2,r3, NULL); ^~ note: passing argument to parameter 'vp' here void free_free_set_them_free(void * vp, ...) |
Hmm, casting each argument will be obviously as tedious as typing separate free calls, if not even more tedious:
1 2 3 4 5 6 |
FREE( (void*)slave[0], (void*)slave[1], (void*)slave[2], (void*)slave[3], (void*)slave[4], (void*)slave[5], (void*)slave[6], (void*)slave[7], (void*)slave[8], NULL /* do not ever forget this as last argument! */ ); |
Clearly not acceptable. So, I have tweaked my variadic macro:
1 2 3 4 |
// variadic macro with casting // of a *first* argument #define FREE(...) \ free_free_set_them_free((void *)__VA_ARGS__) |
This macro now expands into:
1 2 3 4 5 6 7 |
// expansion of a FREE variadic macro // with casting the __VA_ARGS__ free_free_set_them_free( (void*)slave[0], slave[1], slave[2], slave[3], slave[4], slave[5], slave[6], slave[7], slave[8], NULL ); |
Just the first argument is cast as requested. And that pacifies the compiler since the remaining args types are not checked before they are used inside the variadic function. I bet that comes as a surprise.
1 2 3 4 5 6 7 |
// using the FREE variadic macro FREE ( slave[0], slave[1], slave[2], slave[3], slave[4], slave[5], slave[6], slave[7], slave[8], NULL /* do not ever forget NULL as the last argument! */ ); |
And (lo and behold) there is no warning and all is dandy (in the land of macro candy).
But what about this annoying little comment we keep on dragging?
/* do not ever forget NULL as the last argument!
*/
Standard C, variadic functions implementation is based on what is available in <stdarg.h >. There is no mechanism in there to tell us which is the last argument in standard C variadic functions. In this case, we need to use the concept of the “last argument sentinel”. The last argument is therefore a special value (sentinel) that signals the list of arguments is finished. And since the type of every argument is void *
, NULL is the only logical choice.
Fine. I then do the last and final version of my FREE variadic macro, by simply adding the NULL argument in the call:
1 2 3 4 |
// cast the first argument to (void *) // add the NULL as the last argument, so the caller does not have to #define MULTIFREE(...) \ free_free_set_them_free((void *)__VA_ARGS__, NULL) |
A function is implemented to stop if the argument is NULL. And this is one very good example of why sometimes we need variadic macros and how to use them. The call to MULTIFREE looks now pretty normal, and a good replacement for repeated calls to free().
1 2 3 4 |
MULTIFREE( slave[0], slave[1], slave[2], slave[3], slave[4], slave[5], slave[6], slave[7], slave[8] ); |
No casting and no last argument sentinel necessary.
I am sure you can extrapolate this to your various use cases, with variadic functions in standard C.
Yes, we already said: the code is here. It does not exactly match this post. It is better.