Strange behavior of two consecutive printf () calls in C

Question

I played with C; check this:

#include <stdio.h> #include <stdlib.h> void main() { printf("%d\n", 1.5); printf("%f", 0); } 

I was expecting an exit:

 0 0.000000 

but he prints:

 0 1.500000 

Did the first printf() 1.5 pass the second printf() ?

PS: I know ( %d for ints, %f for float). As I said, I was just messing around with the code.

PS2: I am using DevC ++ and Code :: Blocks.

Answer 1

Undefined behavior according to the C standard, here is what can happen on your system:

• For the first call printf("%d\n", 1.5); main is passed a floating point value of 1.5 as double in the first register of XMM and calls printf() .
• printf() does not change the XMM case, because if a floating point operation is not performed to process the format "%d" . It retrieves the printable value from another location: register or stack, and that value is 0 .
• for the second call printf("%f", 0); , main does not change XMM either because it passes the value int 0 through another place, register, or stack.
• the second printf() finally gets the double value for the %f format from the XMM register, where 1.5 is stored earlier. Therefore, the output is 1.500000 .

None of the above is guaranteed in any way, but this is probably the explanation that interests you. Different systems can handle passing parameters differently; they are part of the ABI (Application Binary Interface).

Just for fun, you can try this variation:

 printf("first %d, second %f\n", 1.5, 42); 

which on my system displays first 42, second 1.500000

Answer 2

You have undefined behavior (so randomly bad things could, and you shouldn't expect anything good). With %f , the printf function expects a double (note that when passed as an argument, a float gets promoted to double ), but 0 is an int literal. In addition, different compilers (even different versions of the same compiler) or different optimization flags can create different bad effects.

Read the Lattner blog on What Every C Programmer Should Know About Undefined Behavior .

^{(a good attitude towards undefined behavior is to always try to avoid this, don’t waste time trying to figure out what exactly is happening, but consider UB as something very dirty or “sick”, you always avoid)}

To explain the observed behavior, you need to plunge into the specifics of your particular implementation, especially the ABI and the calling conventions (for à la printf variative functions). Also, look at the generated assembler code ( GCC , compile with gcc -fverbose-asm -S -O1 ); it is possible that a double register is passed to the register (or some stack of the call stack ), different from the int argument (so the printf function receives garbage to sit in this place or register); note also that quite often sizeof(int) can be 4, but sizeof(double) can be 8 (so the amount of data is not even right).

To avoid such errors, use the compilation habit with a good compiler (for example, GCC or Clang / LLVM in free software ) and include all warnings and debugging information (for example, compile with gcc -Wall -Wextra -g with GCC ). The compiler would warn you.

BTW, void main() is illegal. It should be at least int main(void) and preferably int main(int argc, char**argv) , and you should take care of the arguments.

In your example, gcc -Wall -Wextra (using GCC 7) reports (for your april.c source file):

 april.c:4:10: warning: return type of 'main' is not 'int' [-Wmain] void main() { ^~~~ april.c: In function 'main': april.c:5:14: warning: format '%d' expects argument of type 'int', but argument 2 has type 'double' [-Wformat=] printf("%d\n", 1.5); ~^ %f april.c:6:14: warning: format '%f' expects argument of type 'double', but argument 2 has type 'int' [-Wformat=] printf("%f", 0); ~^ %d 

NB: Dev-C ++ and CodeBlocks are not compilers, but an IDE . They both run an external compiler (maybe GCC like MinGW on your system).