Reinterpret cast from float to int - c++

Question

float f = 12.5;
unsigned int _f = *reinterpret_cast<int*>(&f);
std::cout << _f << std::endl; // result: 1095237632
Can some explain me how such casting works? And what is represented by _f?
EDIT
So this number I got 1095237632 after converting to binary is 0b1000001010010000000000000000000 and this binary number is 12.5 in IEEE-754. Do I get it right?

Answer 1

Let's look at two functions. One of them casts float to int it regularly, and one of them reinterpret casts it using reinterpret_cast:
int cast_to_int(float f) {
// Rounds f to an int, rounding towards 0
return (int)f;
}
int reinterpret_cast_to_int(float i) {
// Just copies the bits
return *reinterpret_cast<int*>(&i);
}
So what actually happens? Let's look at the assembly:
cast_to_int(float):
cvttss2si eax, xmm0 // We cast to an int
ret
reinterpret_cast_to_int(float):
movd eax, xmm0 // We directly copy the bits
ret
In the first case, there's an assembly instruction that performs the conversion:
cast_to_int(0.7) -> 0
cast_to_int(1.0) -> 1
cast_to_int(1.5) -> 1
cast_to_int(2.1) -> 2
In the second case, reinterpret_cast just directly transforms the underlying representation of the bits. It's not actually doing anything, and the function just copyies the input register to the output register.
Under the hood, floats have a very different bit representation than ints, and that's why you're getting weird numbers.

Answer 2

Nobody can explain (*), because it does not work.
From cppreference:
Unlike static_cast, but like const_cast, the reinterpret_cast
expression does not compile to any CPU instructions (except when
converting between integers and pointers or on obscure architectures
where pointer representation depends on its type). It is purely a
compile-time directive which instructs the compiler to treat
expression as if it had the type new_type.
Only the following conversions can be done with reinterpret_cast,
except when such conversions would cast away constness or volatility.
And then follows a list of rules covering what reinterpret casts are allowed. Casting type A to a completely unrelated type B is not among them and your code exhibits undefined behaviour.
(*) Strictly speaking not true. You are treating a float as an int and if you look at their representation on your hardware and if you inspect the output of your compiler you can work out why you get the value you get, though undefined behaviour is undefined and its not worth entering details unless you are willing to write nonportable code.

Answer 3

As the comments below say, the usage of reinterpret_cast ist not safe for unrelated types. So don't use it this way.
First, assigning int to uint should be avoided.
For x86/x64 systemns, float is usually represented as 4 bytes, like uint32_t, and they have mostely the same alignment.
Many compilers allow the following:
uint32_t _f = *reinterpret_cast(&f);
But this leads to undefined behavior due to some reasons (thanks for the comments):
- optimizations
- alignment
- ...
Use memcpy instead.
If alignment is the same and the values are stored in memory, the following effect desribes what happens when used reinterpret_cast:
The memory location of the 4 bytes float is &f. With a reinterpret cast to uint32_t, this memory is reinterpretet as an uint32. The dereferenced value _f contains the same bytes as the float f, but interpreted as uint32.
You could cast it back and get the original value 12.5:
float f = 12.5;
uint32_t _f = *reinterpret_cast<uint32_t*>(&f);
float _fnew = *reinterpret_cast<float*>(&_f);
std::cout << _fnew << std::endl; // result: 12.5
reinterpret_cast only reinterpretes memory locations (addresses).
If the alignment is not the same or the values are stored in registers, are optimized an so on, the cast can lead to undefined values.