How to write a macro with optional and variadic arguments

Question

I have a macro called PRINT(...) that I use in my code, which gets a variable number of arguments and acts like printf (gets a format and arguments). It's defined like this:

#define PRINT(...) PRINT(__VA_ARGS__)

Now I want to modify it so it will have an optional argument, say that its name is number and it will add a numeric prefix to the printing. For example:

PRINT("%s", "hi") -> will print hi
PRINT(1, "%s", "hi") -> will print 1: hi

How can I change the PRINT macro to support this?
Important to say, that I don't want to change any existing call to this macro from my code (in the example, if I have a call to PRINT("%s", "hi") - it needs to remain the same after the change).
Also, I can't create new macro for this purpose- must use the existing PRINT macro for this purpose (but off course I can change it's arguemnts definition).
Any idea how can I do this?

Edit: I saw this post about variadic macro- but It's different from what I'm asking here since the argument number needs to be a recognized variable, which will be treated in the implementation of PRINT as -1 if the call to PRINT doesn't contain the number argument (-1 will be an indicator for printing no number) and otherwise it will print the number prefix.

Possible duplicate of [How to make a variadic macro (variable number of arguments)](https://stackoverflow.com/questions/679979/how-to-make-a-variadic-macro-variable-number-of-arguments) — Tony Tannous, Aug 06 '17 at 09:19
@TonyTannous , edited my post. The link you provided didn't solve my problem — John, Aug 06 '17 at 09:44
Consider how you would determine if your `number` argument is present or not. A macro variant would probably be easier. — Hasturkun, Aug 06 '17 at 09:54
is the macro definition of `PRINT(...)` really `PRINT(__VA_ARGS__)`? — Antti Haapala -- Слава Україні, Aug 06 '17 at 10:03
Please now for once **edit the post so that it contains all the necessary requirements in one place for that which you want to achieve**. — Antti Haapala -- Слава Україні, Aug 06 '17 at 12:28
@AnttiHaapala - I wrote all my requirements in the first time I wrote the post. I did only one edit, and it wasn't related to any additional requirement- it was just to clarify that the link that was suggested by the first response isn't duplicate of my case — John, Aug 06 '17 at 12:33
the number -1 isn't important- it can be any. it just an indicator — John, Aug 06 '17 at 12:34
Your post says it needs to support *one* extra case, not million. The `_Generic` is the only standards-compliant one. If you need to actually overload the name `PRINT` in any more complicated way, C isn't your language. — Antti Haapala -- Слава Україні, Aug 06 '17 at 13:32

cdo256 · Answer 1 · 2017-08-06T10:58:16.863

3

As of C11, you can use the _Generic keyword. This allows you to check the type of any value or variable. According to this document, _Generic has behaviour that varies between compilers. This answer provides a simple solution, though, using the comma operator.

#define PRINT(fst, ...) \
( \
    _Generic((0, fst), char *: 1, default: 0) ? \
    PRINTNL(fst, __VA_ARGS__) : \
    PRINTL(fst, __VA_ARGS__) \
)

Where PRINTNL prints without the number and PRINTL prints with the number.

Rest of the code:

#define PRINTNL(...) printf(__VA_ARGS__)
#define PRINTL (n, ...) ({ \
    printf("%d: ", n); \
    printf(__VA_ARGS__); \
})

edited Aug 06 '17 at 10:58

answered Aug 06 '17 at 10:18

cdo256

973
1
11
16

Testing for strings is actually a bit more complicated, this could be `char*` or `char const*`. – Jens Gustedt Aug 06 '17 at 10:36
You're right. It appears to be compiler dependent too. See [this](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1930.htm). – cdo256 Aug 06 '17 at 10:48
Besides the string testing and compiler dependency, it will be pretty problematic solution for me since in the future I might want to add more optional arguments to the PRINT macro- which will make the implementation quite complicated if I use this way (if I understood it right) – John Aug 06 '17 at 12:26
and it could be char array too! – Antti Haapala -- Слава Україні Aug 06 '17 at 12:26
@John this is absolutely the only way to achieve this in C with your new constraints. If you're not happy, either you need to adapt or change the language. – Antti Haapala -- Слава Україні Aug 06 '17 at 12:27
@cdo256, the compiler incompatibility mentioned in that defect report has been resolved by the C committee. – Jens Gustedt Aug 06 '17 at 21:30

score 1 · Answer 2 · answered Aug 06 '17 at 10:09

Since you'd know by the time of writing whether the first argument is a number prefix or not, make a macro by another name for prefixing with the number. Here I assume that PRINT(...) expands to printf(__VA_ARGS__):

#define PRINT(...) printf(__VA_ARGS__)

So define a macro NPRINT that calls printf twice, once to output the prefix with number and once with the format:

#define NPRINT(number, fmt, ...) (printf("%d: ", number), printf(fmt, __VA_ARGS__))

Usage

#include <stdio.h>

int main(void) {
    NPRINT(1, "%s\n", "hi");
}

Of course this doesn't work if the call to printf was supposed to be atomic - now if the format string was always a literal string, then you could use string concatenation:

#define NPRINT(number, fmt, ...) (printf("%d " fmt, number, __VA_ARGS__))

If it can be a variable and only one call to PRINT is allowed, the only portable way that I could see is to make a function that builds the format.

With the latest edit that without the number argument, -1: should be prefixed, this would simply become:

#define PRINT(...) NPRINT(-1, __VA_ARGS__)

The problem here is that I will have to use NPRINT to print with the number prefix, and I can only use PRINT for this purpose — John, Aug 06 '17 at 12:22
@John the only possible solution is if you can use C11 and `_Generic` selection. There is absolutely no other way in standard C then. — Antti Haapala -- Слава Україні, Aug 06 '17 at 12:26
This is certainly the correct approach. Overloading (a form of polymorphism; essentially what the OP is asking for) is a good way to adapt to a type system to get one _conceptual_ function to do _one thing_, but it's wrongheaded if you're asking one conceptual function to do _many things_. `PRINT(` [...arguments...] `)` is one thing. `PRINT(` , , [...arguments...] `)` is another thing. Two things should not both be spelled `PRINT`; that's bad design. — H Walters, Aug 06 '17 at 18:39

Ganindu · Answer 3 · 2021-07-28T12:20:39.550

Please have a look at the ##__VA_ARGS__ macro. Also check the code below written for a log function.

In the header file

/**
 * ##__VA_ARGS__ allows us to make varadic arguments optional
 * https://gcc.gnu.org/onlinedocs/gcc/Variadic-Macros.html
 * also check __VA_OPT__ (C++20)
 */ 

#define APP_LOG(message, ...) \
    do { \
            APP_LOGX( __FILE__, __LINE__, ("\e[1;34m[INFO]: \e[0m" message), ##__VA_ARGS__); /** BLUE */ \
    } \
    while(0)

#define APP_ERROR(message, ...) \
    do { \
            APP_LOGX( __FILE__, __LINE__, ("\e[1;31m[FATAL]: \e[0m" message), ##__VA_ARGS__); /** RED */ \
    } \
    while(0)

In the implementation

/** #include <libgen.h> */
void APP_LOGX(const char * file, int num, const char* message, ...)
{
    va_list ap;
    int length;
    char * tfilename = NULL;
    tfilename = strdup(file);
    
    length = strlen(message);
    if(length>0){
        va_start(ap, message);
        vprintf(message, ap);
        printf(" | File: %s Line %d ", basename(tfilename), num);
        va_end(ap);

        /* add newline if nessasary */
        if(message[length -1] != '\n'){
            printf("\n");
        }
    }

    free(tfilename);
}

Application

 APP_LOG("app display init")

or

APP_LOG("Value of x acceleration %.2f", g);
APP_ERROR("Something bad happened!")

How to write a macro with optional and variadic arguments

3 Answers3