How to represent FLOAT number in memory in C

问题:

While reading a tutorial I came across how to represent Float number in memory. The tutorial had an example with a floating point number.

   float a=5.2  with below Diagram

Can anyone please tell how this 5.2 is converted in to binary and how it is represented in memory in above the above diagram?

回答1:

As was said, 5.2 is represented as a sign bit, an exponent and a mantissa. How do you encode 5.2?

5 is easy:

101. 

The rest, 0.2 is 1/5, so divide 1.00000... (hex) by 5 and you get 0.3333333... (hex).

(This can be followed more easily if you consider one bit less: 0.FFFF... → F / 5 = 3, so it is easy to see that 0.FFFF... / 5 = 0.33333.... That one missing bit doesn\'t matter when dividing by 5, so 1.0000... / 5 = 0.3333... too).

That should give you

0.0011001100110011001100110011... 

Add 5, and you get

101.00110011001100110011...         exp 0    (== 5.2 * 2^0)

Now shift it right (normalize it, i.e. make sure the top bit is just before the decimal point) and adjust the exponent accordingly:

1.010011001100110011001100110011... exp +2   (== 1.3 * 2^2 == 5.2)

Now you only have to add the bias of 127 (i.e. 129 = 0b10000001) to the exponent and store it:

0 10000001 1010 0110 0110 0110 0110 0110 

Forget the top 1 of the mantissa (which is always supposed to be 1, except for some special values, so it is not stored), and you get:

01000000 10100110 01100110 01100110

Now you only have to decide little or big endian.

This is not exactly how it works, but that is more or less what happens when a number like 5.2 is converted to binary.

回答2:

I think the diagram is not one hundret percent correct.

Floats are stored in memory as follows:

They are decomposed into:

• sign s (denoting whether it\'s positive or negative) - 1 bit
• mantissa m (essentially the digits of your number - 24 bits
• exponent e - 7 bits

Then, you can write any number x as s * m * 2^e where ^ denotes exponentiation.

5.2 should be represented as follows:

0 10000001 01001100110011001100110    
S    E               M

S=0 denotes that it is a positive number, i.e. s=+1

E is to be interpreted as unsigned number, thus representing 129. Note that you must subtract 127 from E to obtain the original exponent e = E - 127 = 2

M must be interpreted the following way: It is interpreted as a number beginning with a 1 followed by a point (.) and then digits after that point. The digits after . are the ones that are actually coded in m. We introduce weights for each digit:

bits in M: 0   1    0     0      1       ... 
weight:    0.5 0.25 0.125 0.0625 0.03125 ... (take the half of the previous in each step)

Now you sum up the weights where the corresponding bits are set. After you\'ve done this, you add 1 (due to normalization in the IEEE standard, you always add 1 for interpreting M) and obtain the original m.

Now, you compute x = s * m * 2^e and get your original number.

So, the only thing left is that in real memory, bytes might be in reverse order. That is why the number may not be stored as follows:

0 10000001 01001100110011001100110    
S    E               M

but more the other way around (simply take 8-bit blocks and mirror their order)

01100110 01100110 10100110 01000000
MMMMMMMM MMMMMMMM EMMMMMMM SEEEEEEE

回答3:

The value is represented in memory in reverse order, but the confusing point may be that 5.2f is really represented as 5.1999998 due to the accuracy loss of the floating point values.

回答4:

Representing 5.2 is very simple in binary logic:

     8 4 2 1
5 -> 0 1 0 1

For a decimal number:

Take .2 and multiply by 2 (since it is represented in binary).

.2 X 2 = 0.4 -> take the value after the
                decimal point, don\'t take the value before
                the decimal point

.4 X 2 = 0.8
.8 X 2 = 1.6
.6 X 2 = 1.2
.2 X 2 = 0.4

and so on...

After this step, take the value before the decimal point from output of the above steps:

.2 X 2 = 0.4 -> take 0 from this for representing in binary form

So the final o/p of 5.2 is:

0101.00110...

回答5:

Raw float 5.2:

01000000101001100110011001100110
^ sign bit

In memory, reverse byte order (as your diagram):

01100110011001101010011001000000
                        ^ sign bit

回答6:

5.2

The number is stored in form of \"Sign Bit,Exponent,Mantissa. in binary form of 5 is 8 4 2 1 so 0101 and .2 is

.2*2=.4   0
.4*2=.8   0
.8*2=1.6  1

and sign bit 0 Because Number is positive.

0 0101 001....

回答7:

5.2 in binary 101.00110011...... ------> non normalized form 5.2 is .10100110011.... x 2^3 ------> explicit normal form 5.2 is .0100110011 x 2^3 in implicit normal form

here sign bit becomes 0 (because the number is positive) and exponent is seven bit so it is using excess 64 exponent notation so exponent will become 64+3 = 69 ie 1000101 and remaining will be mantissa (total 32bit - 7 exponent bit - 1 sign bit = 24 bit) 0100 1100 1100 1100 1100 1100

In the above example sign bit is correct Excess 64 is not applied , so not normalized but ideally it should use implicit normalization Mantissa part in second byte if you apply implicit normalization the MSB \'1\' will not come .

回答8:

5.2 is represented as \"01000000101001100110011001100110\"

Check the Converter Applet

回答9:

The conversion technique posted originally on the other website is shown unnecessarily complex (although it takes us to right answer) . For memory representation of 5.2 in memory:

First convert it into simple binary system, which will give us 101.001100110011001100110011

Now change it into scientific form : 1.01001100110011001100110011 x 10^2 .

Now our sign bit is 0 as the number is positive

For exponent we need (127 + 2) upto 8 bits which gives us 10000001

Fraction is 01001100110011001100110 . (23 bits) (Discarding the leading 1 of scientific form)

=> the representation is

0 10000001 0100 1100 1100 1100 1100 110

回答10:

Below two references really helped me understand the IEE 754 floating point number encoding in binary format,

http://www.pitt.edu/~juy9/142/slides/L3-FP_Representation.pdf

http://en.wikipedia.org/wiki/Single-precision_floating-point_format

回答11:

int a;
float b=5.2;
memcpy(&a, &b, 4);
printf(\"%d\",a);

This gives 0100 0000 1010 0110 0110 0110 1000 0001 (1084647041)