Struggling with union output - c

Question

I'm trying to figure out this code for about an hour and still no luck.
#include <stdio.h>
#include <stdlib.h>
int f(float f)
{
union un {float f; int i;} u = {f};
return (u.i&0x7F800000) >> 23;
}
int main()
{
printf("%d\n", f(1));
return 0;
}
I don't understand how this work, I've tried f(1), f(2), f(3), f(4) and of course getting the different results. I've also read a lot about unions and stuff. What I have noticed that when i delete 0x7F800000 from return, results will be the same. I wanna know how u.i is generated, obviously it is not some random garbage but also it is not one (1) from function argument. What is going on here, how does it work?

Answer 1

This really amounts to an understanding of how floating point numbers are represented in memory. (see IEEE 754).
In short, a 32-bit floating point number will have the following structure
bit 31 will be the sign bit for the overall number
bits 30 - 23 will be exponent for the number, biased 127
bits 22 - 0 will represent the fractional part of the number. This is normalized such that the digit before the decimal (actually binary) point is one.
With regards to the union, recall that a union is a block of computer memory that can hold one of the types at at time, so the declaration:
union un
{
float f;
int i;
};
is creating a 32-bit block of memory that can either hold a floating point number or an integer, at any given time. Now when we call the function with a floating point parameter, the bit-pattern of that number is written to the memory location of un. Now when we access the union using the i member, the bit pattern is treated as an integer.
Thus, the general layout of a 32-bit floating point number is seee eeee efff ffff ffff ffff ffff ffff, whese s represents the sign bit, e the exponent bits and f the fraction bits. OK, kind of gibberish, hopefully an example might help.
To convert 4 into IEEE floating point, first convert 7 into binary (I've split te 32-bit number into 4-bit nibbles);
4 = 0000 0000 0000 0000 0000 0000 0000 0111
Now we need to normalize this, i.e. express this as a number raised to the power of two;
1.11 x 2^2
Here we need to remember that each power of two move the binary point to the right on place (analogous to dealing with powers of 10).
From this, we now can generate the bit pattern
the overall sign of the number is positive, so the overall sign bit is 0.
the exponent is 2, but we bias the exponent with 127. This means that an exponent of -127 would be stored a 0, while an exponent of 127 would be stored as 255. Thus our exponent field would be 129 or 1000 0001.
Finally our normalized number would be 1100 0000 0000 0000 0000 000 000. Notice we have dropped the leading `1' because it always assumed to be there.
Putting this all together, we have as the bit pattern:
4 = 0100 0000 1110 0000 0000 0000 0000 0000
Now, the last little bit here is the bit-wise and with 0x7F800000 which if we
write out in binary is 0111 1111 1000 0000 0000 0000 0000 0000, If we compare this to the general lay out of an IEEE floating point number, we see that what we are selecting with the mask is the exponent bits, and then we are shifting the to the left 23 bits.
So your program is just printing out the biased exponent of a floating point number. As an example,
#include <stdio.h>
#include <stdlib.h>
int f(float f)
{
union un {float f; int i;} u = {f};
return (u.i&0x7F800000) >> 23;
}
int main()
{
printf("%d\n", f(7));
return 0;
}
gives an output of 129 as we would expect.