`printf()` 如何区分浮点参数和整数类型参数？

Question

If I have

printf("%f\n", 3);

I get

3.000000

And if I have:

printf("%f\n", 3.0);

I get the same answer.

But here's the thing, 3 and 3.0 should be completely different, bit wise.

3.0 should be something like 01000000010000000000000000000000 (but double precision because of implicit conversion in vararg functions)
3 should be something like 00000000000000000000000000000011

3 must somehow be converted to a float before being displayed.

So my question is, how is this done? Does the compiler cheat somehow? How would I implement this in my own variable args function?

Answer 1

If your source code contained printf("%f\\n", 3); and the resulting output was “3”, then what most likely happened was something like:

• There is a floating point 3 somewhere else in your program, such as for an assignment statement like x = 3.; or another printf call such as printf("%f\\n", 3.0); .
• In order to work with that 3, the compiler loaded it into a floating-point register. It might have done this for code prior to your printf or as preparation for code that is after your printf .
• When printf("%f\\n", 3); was evaluated, that floating-point 3 was in the register where a double argument is supposed to be when printf was called with a %f conversion specifier.
• So, since the register used to pass an argument for %f happened to have a floating-point 3 in it, the printf used that value and produced a result of “3”.

In other words, your program happened to “work” largely by happenstance, not by design. You did in fact call printf incorrectly, and it only produced “3” because unrelated factors happened to work out. If the value in that floating-point register had been 5 or −3.25, then printf would have printed that value instead.

The printf routine does not have a way of determining which types of values you passed it. (Good compilers do check the types at compile-time, if the format string is a literal [rather than something computed at run-time]. But that is done by the compiler looking at the source code for the call, not by the printf routine itself.)

Answer 2

How does printf() distinguish between floating point arguments and integer type arguments?

printf() relies on the calling code to pass objects of the expected type per its format .

---

printf() analyzes the format string , which in this case is "%f\\n" .

The "%f" steers code to expect that the next parameter is a double .

If a float is passed, it is converted to a double as part of the usual conversion of arguments to the ... part of a function.

With a float/double passed by the calling code, printf() will properly get that data as a double and print it. If the calling code passed some other type, the result is undefined behavior (UB) . This UB is well explain by @Eric Postpischil .

how is this done? Does the compiler cheat somehow?

How would I implement this in my own variable args function?

The unexpected undefined behavior seen by OP is not certainly reproducible with user code.