C++ Macros with variable number of arguments

C++ Macros with a variable number of arguments, or even worse sounding “Variadic Macro’s“.

Why would anybody need this? Like C++ is not “hard enough” already, one might exclaim? Well. standard C/C++ is not hard.  But to learn anything properly, good examples are priceless. Here is one good example.

(Working code example)

In C it is extremely important to get into the habit to free() anything that can be freed and to do it all the time. 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”.   Now the test code. First here is some heap-allocated data, that requires a lot of free() calls afterwards.

In C there are no destructors, so you better be sure you have cleaned up after yourself. Good example is code like above, with a mandatory, long and tedious sequence of calls to standard function free() that has to come after it :

This is not very nice. And it is a bit tiresome. So, I have developed a variadic function with a signature like this:

And, I have developed a variadic macro with a normal name to use this useful function:

Syntax is simple. And the predefined __VA_ARGS__ that will become arguments list expanded. Now I can ease (a bit), a burden of repeated free calls:

But. Dear CLANG (aka LVVM) in its standard C reincarnation screams at me now:

Hmm, casting each argument will be obviously as tedious as typing separate free calls, if not even  more tedious:

Not acceptable.  So, I have tweaked my variadic macro:

This macro now expands into:

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.

And (lo and behold) there is no warning and all is dandy.

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.  We need to have the concept of the “last argument sentinel”.

Fine. I then do the last and final version of my FREE variadic macro, by simply adding the NULL argument in the call:

A function is implemented to stop if the argument is NULL. And this is one very good example why sometimes we need variadic macros and how to use them. The call to FREE looks now pretty normal, and a good replacement for repeated calls to free().

No casting and no last argument sentinel necessary.

I am sure you can extrapolate this to your use cases, with variadic functions in standard C.

In case anybody wants a implementation of:

Please do let us know in the comments below this post.

So little C++ so much good!
So little C++ so much good!

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.