直接将浮点变量分配为十六进制整数与通过指针转换分配之间的区别

Question

I was investigating the structure of floating-point numbers, and I've found that most of compilers use IEEE 754 standard to store floating point numbers. And when I tried to do:

float a=0x3f520000; //have to be equal to 0.8203125 in IEEE 754
printf("value of 'a' is: %X [%x] %f\n",(int)a,(int)a, a);

it produces the result:

value of 'a' is: 3F520000 [3f520000] 1062338560.000000

but if I try:

int b=0x3f520000;
float* c = (float*)&b;
printf("value of 'c' is: %X [%x] %f\r\n", *(int*)c, *(int*)c, c[0]);

it gives:

value of 'c' is: 3F520000 [3f520000] 0.820313

The second try gave me the right answer. What is it wrong with the first try? And why does the result differ from that when I cast int to float via pointer?

Answer 1

_{[Note: This answer assumes C, not C++, which have different rules]}

With

float a=0x3f520000;

you take the integer value 1062338560 and the compiler will convert it to 1062338560.0f .

If you want hexadecimal floating point constant you must use exponent-format using the letter p . As in 0x1.a40010c6f7a0bp-1 (which is the hexadecimal notation for 0.820313 ).

What happens with

int b=0x3f520000;
float* c = (float*)&b;

is that you break strict aliasing and tell the compiler that c is pointing to a floating-point value (the strict aliasing break is because b isn't a floating point value). The compiler will then reinterpret the bits in *c as a float value.

Answer 2

The difference is that the first converts the value ( 0x3f520000 is the integer 1062338560), and is equivalent to this:

float a = 1062338560;
printf("value of 'a' is: %X [%x] %f\n",(int)a,(int)a, a);

The second reinterprets the representation of the int - 111111010100100000000000000000 - as being the representation of a float instead.
(It's also undefined, so you shouldn't expect it to do anything in particular.)

Answer 3

0x3f520000 is an integer constant. When assigned to a float, the integer is converted.

Answer 4

Some more proper example of how to convert in the second case:

#include <stdio.h>
#include <string.h>
#include <stdint.h>

int main() {
  uint32_t fi = 0x3f520000;
  float f;
  memcpy(&f, &fi, sizeof(f));
  printf("%.7g\n", f);
}

it prints:

0.8203125

so that is what you expected.

The approach I used is memcpy that is the safest for all compilers and best choice for modern compilers (GCC since approx. 4.6, Clang since 3.x) that interpret memcpy as "bit cast" in such case and optimize it in a efficient and safe way (at least in "hosted" mode). That's still safe for older compilers, but not nessessarily efficient in the same way; some can prefer cast through union or ever through different pointer type. On dangers of that ways, see here or generally search "type punning and strict aliasing".

(Also, there could be some weird platforms that suffer from endianness issue that integer endianness differs from float one; ones that have byte different than 8 bits, and so on. I don't consider them here.)

UPDATE: I was starting answering to initial version of the question. Yep, bit casting and value conversion will give principally different results. That's how float numbers work.