3 
#include<stdio.h>
#include<stdlib.h>

int main(void)
{
  int x, *ptr_x;
  float f , *ptr_f;

  ptr_f = &f;
  ptr_x = &x;
  *ptr_x = 5;
  *ptr_f = 1.5; //printf("%d %f\n", f,x);

  printf ("\n\nxd = %d \t xf = %f \n ff = %f \t fd = %d", x,x,f,f);
  return 0;
}

The output for ff = %f is not expected.

xd = 5 xf = 0.000000
ff = 0.000000 fd = 1073217536

The point of the this code is to show what would happen if a floating value is printed with %d and if a int value is printed %f.

Why is the float value not being printed properly even if i use %f ?

Improve this question

3 Answers 3

Reset to default
16

printf() is not typesafe.

The arguments that you pass to printf() are treated according to what you promise the compiler.

Also, floats are promoted to doubles when passed through variadic arguments.

So when you promise the compiler %f the first time (for xf), the compiler gobbles up an entire double (usually 8 byte) from the arguments, swallowing your float in the process. Then the second %f cuts right into the zero mantissa of the second double.

Here's a picture of your arguments:

+-0-1-2-3-+-0-1-2-3-+-0-1-2-3-4-5-6-7-+-0-1-2-3-4-5-6-7-+
|    x    |    x    |        f        |        f        |
+---------+---------+-----------------+-----------------+

%d--------|%f----------------|%f---------------|%d------|

But f looks like this (having been promoted to double):

f = 3FF8000000000000

Let's draw it again with values, and speculating about your machine endianness:

| 05000000 | 05000000 | 00000000 0000F83F | 00000000 0000F83F |
| %d, OK   | %f, denormal...    | %f, denormal...   | %d, OK  |

Note that 1073217536 is 0x3FF80000.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

This is highly implementation-defined. For some compilers it might be correct. For others - not. For example, some modern 64-bit compilers pass all variadic arguments in 8-byte fields regardless of their actual size (instead of packing them tightly, as in your picture). If the OP used such compiler, the problem would probably stay hidden.
Yes, just about everything about this answer is entirely machine-dependent, and it's rife with speculation and fiction. About the only portable part of it is the initial admonition.
Wow, thanks so much for taking the time to create such a helpful diagram, brilliant! But why and how do the floats get promoted? Does a similar thing happen if I pass a float to a user-defined function? What do you mean by variadic arguments?
ok.. I googled variadic functions, still.. I don't get why the promotion is required.
@tera: The promotion is just part of the rules of variadic arguments. I don't have the reference at the top off my head, but I can look it up if you like. Chars and shorts get promoted to ints, and floats to doubles. Note how you only have format specifiers %f and %Lf, but nothing for float. There might be subtle differences between C and C++ though, I'm not sure now, I'll have to check.
|
3

Once you pass at least one invalid format specifier to printf (like attempt to print a float value with %d or an int value with %f) your entire program gets screwed up beyond repair. The consequences of such destructive action can be seen anywhere in the program. In your case an attempt to print something with an invalid format specifier resulted in that even the valid format specifiers stopped working.

Speaking formally, you wrote a program that exhibits undefined behavior. It can act absolutely unpredictably. You said it yourself

The point of the this code is to show what would happen if a floating value is printed with %d and if a int value is printed %f.

The broken behavior that you observe demonstrates exactly that! A bizarrely and unpredictably acting program is exactly what happens when you attempt to do something like that.

Improve this answer

Comments

0

Try this:

printf("size of int = %d, size of float = %d, size of double = %d\n",
    sizeof(int), sizeof(float), sizeof(double));

When you call printf(), the system pushes the arguments onto the stack. So the stack looks something like this:

pointer to format string [probably 4 bytes]
x [probably 4 bytes]
x [probably 4 bytes]
f [probably 6 or 8 bytes]
f [probably 6 or 8 bytes]

Then printf() pops bytes off the stack as it parses the format string. When it sees %d it pops enough bytes for an int, and when it sees %f it pops enough bytes for a float. (Actually, floats are promoted to doubles when they're passed as function arguments, but the important idea is that they require more bytes than ints.) So if you "lie" about the arguments it will pop the wrong number of bytes and blindly convert them according to your instructions.

So it will first pop the correct number of bytes for xd because you've correctly told it that x is an int.

But then it will pop enough bytes for a float, which will consume the second x and part of the first f from the stack, and interpret them as a float for xf.

Then it will pop off enough bytes for another float, which will consume the remainder of the first f and part of the second f, and interpret them as a float for ff.

Finally, it will pop off enough bytes for an int, which will consume the remainder of the second f, and interpret them as an int for fd.

Hope that helps.

Improve this answer

11 Comments

"...system pushes the arguments onto the stack". And if the system doesn't have a stack? What happens in that case?
thank you so much this makes a lot of sense. But what do you mean the float gets promoted to doubles? What is the logic behind this? Seems to me this is exactly why I am facing this problem, i.e. if float was kept as 4 bytes and not promoted to 8 bytes, everything would have worked out fine. On my machine, ints and floats are 4 bytes and double is 8 bytes.
@tera: That's how functions without prototypes as well as variadic functions work in C. All smaller integer values are promoted to int, while all smaller floating-point types are promoted to double. In other words, it is impossible to literally pass a char, short or float value to a variadic function. Every time you do that, the value is promoted first.
@AndreyT: Every C program has at least one stack and heap; they're nothing more than one or more chunks of preallocated memory. The startup code that runs before your main() routine performs the "magic" that allocates the memory, initializes the stack pointer and global/static variables, and any other necessary housekeeping. A good debugger will let you step through this code and watch the initialization take place. You can usually find the source for the startup code in your compiler libraries or build tools. An example is here: bravegnu.org/gnu-eprog/c-startup.html
@Adam Liss: Not really. Every C program, has freestore (or "heap"), but the existence of physical "stack" is not guaranteed at all. There's no "stack" in the language specification. And physical stack isn't really required, especially when it comes to argument passing. On some older platforms, for example, stack exists, but is too small and valuable to "waste" on local storage and even for argument passing.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.