How to use GCC's printf format attribute with C++11 variadic templates?

问题

I have a C++ class that is the frontend for a logging system. Its logging function is implemented using C++11's variadic templates:

template <typename... Args>
void Frontend::log(const char *fmt, Args&&... args) {
  backend->true_log(fmt, std::forward<Args>(args)...);
}

Each logging backend implements its own version of true_log, that, among other things, uses the forwarded parameters to call vsnprintf. E.g.:

void Backend::true_log(const char *fmt, ...) {
  // other stuff..
  va_list ap;
  va_start(ap, fmt);
  vsnprintf(buffer, buffer_length, fmt, ap);
  va_end(ap);
  // other stuff..
}

Everything works great, and I am happy.

Now, I want to add a static check on the log() parameters: specifically, I would like to use GCC's printf format attribute.

I started by tagging the log() function with __attribute__ ((format (printf, 2, 3))) (as this is the first "hidden" parameter, I need to shift parameter indices by one). This does not work, because if fails with a compilation error:

error: args to be formatted is not ‘...’

Then, I tried to add the same attribute to the true_log() function. It compiles, but no error checking is actually performed: I tried to pass to log() some invalid format/variable combinations, and no warning was issued. Maybe this kind of check is "too late", or, in other words, the information about the variable has been lost in the chain of calls?

As a last resort, if I annotated log() with __attribute__ ((format (printf, 2, 0))), I would receive warnings about wrong format strings, but no diagnostic would be issued for invalid format/variable combinations.

Summarizing the problem: how can I have full format checking from GCC if I use C++11's variadic templates?

回答1:

I don't believe you can. I bet that GCC only verifies the format string if it's a literal. This is why putting the format attribute on true_log doesn't work - that function is called with what looks (syntactically) like a runtime-determined string. Putting it on log directly would circumvent that, but would require format attributes to support variadic template, which you proved it doesn't.

I suggest that you look at more C++-ish ways to do formatted output. There is, for example, boost::format which works kind of like printf, but dynamically verifies that the number and types of the parameters types match the format string. It doesn't use variadic templates, though, but instead consumes parameters fed to it (via operator %) one-by-one.

回答2:

For the record, I ended up removing the C++11 variadic templates altogether, and using a traditional va_list.

__attribute__((format(printf, 2, 3)))
void Frontend::log(const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  backend->true_log(fmt, ap);
  va_end(ap);
}

void Backend::true_log(const char *fmt, va_list ap) {
  // log the message somehow
}

回答3:

There is a workaround if you are willing to use a macro.

There are constructs that will cause the compiler to do the checking for you, but will not generate any called code. One such construct is sizeof. So, you could use a macro for your logger to pass the arguments to printf directly but in the context of a sizeof calculation, and then call the logger itself.

The reason to use a macro is to make sure the format string is treated just like a string literal would be treated.

In the illustration below, I treat the sizeof calculation as a throwaway argument, but there should be other ways to apply the same technique.

template <typename... Ts>
void Frontend::log(size_t, const char *fmt, Ts&&... args) {
  backend->true_log(fmt, std::forward<Ts>(args)...);
}

#define log(...) log(sizeof(printf(__VA_ARGS__)), __VA_ARGS__)

Try it online!

Of course, this is a workaround. There are numerous reasons not to use a macro. And in this case, the log macro would interfere with any other function or method with the same name.

来源：https://stackoverflow.com/questions/12573968/how-to-use-gccs-printf-format-attribute-with-c11-variadic-templates