Deducing variadic template arguments with default arguments

Question

I am trying to create a basic logger. Here is a small example.

template
struct log {
    log(
        str &&...args,
        const char  *file = __builtin_FILE(),
        const char  *func = __builtin_FUNCTION(),
        const size_t line = __builtin_LINE()
    ) {

        std::cout << "[" << file << "] [" << func << "] [" << line << "] ";
        ((std::cout << args << " "), ...);
        std::cout << std::endl;
    }
};

template
log(str &&...args) -> log;

I want the ability to receive caller information along with a variable number of arguments. With the above example, I can create an instance like this.

log inst("THIS WORKS", "ASD", "ASD");

>>> [.../main.cpp] [main] [10] THIS WORKS ASD ASD

I also want the ability to specify logging levels. This is where the trouble begins. Say I have an enum with the following logging levels, and I want to make it a template argument for the logger. The following is how I thought this would work.

enum logging_level {
    INFO,
};

template
struct log {
    ...
};

template
log(str &&...args) -> log;

log inst("THIS DOESN'T WORK", "ASD", "ASD");

The error I get here is that the arguments are passed into the default arguments, not the variadic arguments.

>>> error: invalid conversion from ‘const char*’ to ‘size_t’ {aka ‘long unsigned int’} [-fpermissive]
>>>    33 |     log inst("THIS DOESN'T WORK", "ASD", "ASD");
>>>       |                                                ^~~~~
>>>       |                                                |
>>>       |                                                const char*

This is getting well above my C++ template knowledge. An easy solution is to ditch the variadic template and just pass in a string but I wanted to see if this could work. Does anyone know how to make this compile?

Thanks.

user_2991525 · Answer

You cannot use CTAD on some arguments, but not on the others. You could make a similar syntax work though using tag dispatch. You need to move the specification of the log level to the argument list to accomplish this.

Note that in the following example I'm using std::source_location (C++20) to be compiler independent:

enum class LogLevel
{
    INFO
};

template
struct LogLevelInfoTag {
    constexpr operator LogLevel()
    {
        return logLevel;
    }
};

constinit LogLevelInfoTag INFO;

template
struct log {
    log(
        LogLevelInfoTag,
        str &&...args,
        std::source_location location = std::source_location::current()
    ) {

        std::cout << "[" << location.file_name() << "] [" << location.function_name() << "] [" << location.line() << "] ";
        ((std::cout << args << " "), ...);
        std::cout << std::endl;
    }
};

template
log(LogLevelInfoTag, str &&...args) -> log;

// log inst("THIS DOESN'T WORK", "ASD", "ASD"); // (desired syntax)
log inst(INFO, "THIS DOESN'T WORK", "ASD", "ASD");

Deducing variadic template arguments with default arguments

1 Answers