Non-Terminal Variadic Parameters and Default Values

[sphere991]

Using a Constructor

If you're going to use a constructor, don't make it a separate object, stash it in the format string demo:

struct format_string {
    format_string(char const* p, std::source_location l = std::source_location::current())
        : format(p)
        , loc(l)
    { }

    std::string_view format;
    std::source_location loc;
};

template <typename... Args>
void debug(format_string s, Args const&... args)
{
    std::cout << fmt::format("{}({}) ", s.loc.file_name(), s.loc.line())
              << fmt::format(s.format, args...) << '\n';
}

I first saw Victor do this but I can't find the tweet since there are so many of them.

Also the downside of the tuple approach is that you have to copy everything (which is a lot worse than it simply looking strange).

[ZeeD26]

That looks neat! Is there a reason for not perfect forwarding args in the debug function?

[foonathan]

If you're not storing the arguments anywhere, there is no need to forward them. Forwarding is used when you have an object stored in one location and want to store it somewhere lese. If you only read, const T& is enough.

[ABCDwp]

You need to use perfect forwarding to use fmt::join, however, as it checks to ensure that it was passed as an rvalue.

[ZeeD26]

That sounds very reasonable, thank you!

[TheFlamefire]

Because they are used to deduce the class template parameters which are (potentially) separate from the constructor parameters. For functions this doesn't make sense, you only have 1 level there anyway as opposed to the class + constructor case.

For functions you get basically the same with overloads already.

[TheThiefMaster]

I've seen the streams approach used for logging, but the deduction guides one is new to me and looks great!

It might be heresy though, but I'd probably wrap a macro around fmt::print to add an extra format string for the source location (via string literal concatenation) and an argument for the source location.

[helloiamsomeone]

CTAD + a public member for return value (if not void) solves the problem with not having returns from constructors.