how to get compilation warnings like in printf inside class member function - c++

Question

I want to write logger which would print logs to console using printf function.
Let's assume that I have following piece of code:
class Logger {
public:
Logger(std::string header = "") : header_(header) {}
template<class ...Args>
void LogInfo(const char* message, Args... args);
private:
std::string header_;
};
template<class ...Args>
void Logger::LogInfo(const char* message, Args... args) {
printf(message, args...);
}
This logs well but problem is when I call:
const char* s = "Monty Python";
Logger logger("[Header]");
logger.LogInfo("%d", s);
logger prints pointer-value without any warning, while printf call causes error (with my compilation flags)
error: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘const char*’ [-Werror=format=]
printf("%d", s);
The point of whole code is that I want to get this error during LogInfo call.
How can I do such a thing?

Answer 1

Falling back to printf function family and format strings brings you back quite a lot of issues concerning type safety You might be better off with modern C++ streaming mechanism. Sure, one wouldn't really want to log like this:
logger << "first: " << x << "second: " << y << commit;
So coming up with some alternative approach avoiding the problem with need for appropriate format string parameters; idea is the following:
arguments are inserted one after another at designated locations in the format string
insertion locations are identified by the character pattern %#
pattern %## suppresses argument insertion and is replaced with the insertion pattern as string
Disadvantage: we have to do the parsing ourselves:
void logInfo(char const* message)
{
char const* m = message;
while((m = strchr(m, '%')))
{
if(*++m == '#')
{
if(*++m != '#')
{
std::cout.write(message, m - message - 2);
std::cout << "<missing argument>";
}
else
{
std::cout.write(message, m - message);
++m;
}
message = m;
}
}
std::cout << message << std::endl;
}
template<typename A, typename ... AA>
void logInfo(char const* message, A a, AA ... aa)
{
char const* m = message;
while((m = strchr(m, '%')))
{
if(*++m == '#')
{
if(*++m != '#')
{
std::cout.write(message, m - message - 2);
std::cout << a;
return logInfo(m, aa...);
}
std::cout.write(message, m - message);
message = ++m;
}
}
std::cout << message << std::endl;
}
Sure, there is quite some common code yet, leaving to you to optimise, it's just for the idea...
Worked fine with the following examples:
logInfo("t1");
logInfo("t2", 7);
logInfo("t3: %#", 12);
logInfo("t4: %#%##", 10);
logInfo("t5: %#%%#", 12);
logInfo("t6: %#% baz", 10);
logInfo("t7 1: %# 2: %# 3: %#", 10, 12);
You might add further formatting options such as minimal output width, fill characters, precision, ... – just as printf provides as well...
Sure, this answer does not match exactly your question ("how to produce a warning"), instead, it simply makes the warning obsolete...

Answer 2

Ok, I hoped someone else said it, but I guess I'll be the one to bring macros...
#define LogInfo(logger, format, ...) printf("%s " format, logger.header().c_str(), __VA_ARGS__);
In order to illustrate what can be achieved, I assumed you wanted to add the logger header at each line. This is just an example.
You'd use it that way:
#include <cstdlib>
#include <string>
#include <iostream>
class Logger {
public:
Logger(std::string header = "") : header_(header) {}
std::string const& header() const { return header_; }
private:
std::string header_;
};
#define LogInfo(logger, format, ...) printf("%s " format, logger.header().c_str(), __VA_ARGS__);
int main()
{
const char* s = "Monty Python";
Logger logger("[Header]");
//LogInfo(logger, "%d", s); // error: format '%d' expects argument of type 'int', but argument 3 has type 'const char*' [-Werror=format=]
LogInfo(logger, "%s", s); // [Header] Monty Python
}
Demo: http://coliru.stacked-crooked.com/a/ad698776f2b0ed4f

Answer 3

As pointed out in comments the printf format errors can be used through the format attribute. But you have to loose the vardiag templates for that or add another level of indirection from the vardiac template function to a simple C vardiac function.
The format specifier is implicit in gcc (and other compilers) definition of printf and explicit for many other printf like functions. e.g.
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, _G_va_list __arg)
__THROWNL __attribute__ ((__format__ (__printf__, 3, 0)));
Because of the attribute the vsnprintf will give the same warnings as a plain printf does. See the linked docs for how to specify the format attribuet for your function (after loosing the vardiac template). Note: Conversion to a plain vardiac function means you have to call vprintf using the varargs macros of the compiler.