Alex Rivera | Logout

How to get printf style compile-time warnings or errors

Asked 2010-06-23T20:07:06.493
16

I would like to write a routine like printf, not functionally-wise, but rather I'd like the routine to have the same time compile check characteristics as printf.

For example if i have:

{
   int i;
   std::string s;
   printf("%d %d",i);
   printf("%d",s.c_str());
}

The compiler complains like so:

1 cc1plus: warnings being treated as errors
2 In function 'int main()':
3 Line 8: warning: too few arguments for format
4 Line 9: warning: format '%d' expects type 'int', but argument 2 has type 'const char*'

code example

Are printf and co special functions that the compiler treats differently or is there some trick to getting this to work on any user defined function? The specific compilers I'm interested in are gcc and msvc

c++ printf typechecking
Edit
Report

2 Answers

23

Different compilers might implement this functionality differently. In GCC it is implemented through __attribute__ specifier with format attribute (read about it here). The reason why the compiler performs the checking is just that in the standard header files supplied with GCC the printf function is declared with __attribute__((format(printf, 1, 2)))

In exactly the same way you can use format attribute to extend the same format-checking functionality to your own variadic functions that use the same format specifiers as printf.

This all will only work if the parameter passing convention and the format specifiers you use are the same as the ones used by the standard printf and scanf functions. The checks are hardcoded into the compiler. If you are using a different convention for variadic argument passing, the compiler will not help you to check it.

answered 2010-06-23T20:42:12.473
1

Actually printf doesn't have any inherent compile-time safety at all. It just happens that some more recent compilers have implemented special checks given that they know exactly what a format string means in terms of the additional parameters. When you use ... as a parameter you're saying that you want to accept arbitrary arguments and accept full responsibility for making sure they're correct. There's no way for the compiler to check them for count/type safety.

Instead of trying to get the compiler to help you in this way, try using the approach used by standard streams: Make use of a (possibly template) function or operator that returns a reference to this to allow chaining. Then the compiler will be able to tell you right away when the arguments don't match what's expected/supported.

answered 2010-06-23T20:16:44.880

Your Answer