What's the meaning of (int&) conversion in C++

Question

There are such code.

float b = 1.0f;
int i = (int) b;
int& j = (int&)b;
cout<<i<<endl;
cout<<j<<end;

Then the output of i was 1, and the output of 1065353216! It's a big surprise to me! So what's the truly meaning of (int&) conversion in C++. Any help or hints are very appreicated!

Answer 1

This is the problem with a C-style cast. You have to look closely to see what you're getting. In your case "(int)" was a normal static cast. The value is converted to an int via truncation. In your case "(int&)" was a reinterpret cast. The result is an lvalue that refers to the memory location of b but is treated as an int. It's actually a violation of the strict aliasing rules. So, don't be surprized if your code won't work anymore after turning on all optimizations.

Equivalent code with C++ style casts:

float b = 1.0f;
int i = static_cast<int>(b);
int& j = reinterpret_cast<int&>(b);
cout<<i<<endl;
cout<<j<<end;

Check your favorite C++ book on these kinds of casts.

Answer 2

Seems like you are trying to create an int reference to a float by using (int&) cast. That will not work since floats are represented differently than int. This will not work.

If the representation of float and int are same then it might have worked.

Answer 3

float b = 1.0f;
...
int& j = (int&)b;

In the second conversion, you're looking at the memory space that contains b as if it was a memory space that contains an int. Floating point values are stored in a manner that's completely different as integers, so the results are really different...

Answer 4

In hexadecimal 1065353216 is 0x3F800000. If you interpret that as a 32-bit floating point number you get 1.0. If you write it out in binary you get this:

3    F    8    0    0    0    0    0
0011 1111 1000 0000 0000 0000 0000 0000

Or grouped differently:

0 01111111 00000000000000000000000
s eeeeeeee vvvvvvvvvvvvvvvvvvvvvvv

The first bit (s) is the sign bit, the next 8 bits (e) are the exponent, and the last 23 bits (v) are the significand. "The single precision binary floating-point exponent is encoded using an offset binary representation, with the zero offset being 127; also known as exponent bias in the IEEE 754 standard." Interpreting this you see that the sign is 0 (positive), the exponent is 0 (01111111_b = 127, the "zero offset"), and the significand is 0. This gives you +0⁰ which is 1.0.

Anyhow, what's happening is that you are taking a reference to a float (b) and reinterpreting it as an int reference (int&). So when you read the value of j you get the bits from b. Interpreted as a float those bits mean 1.0, but interpreted as an int those bits mean 1065353216.

For what it's worth, I have never used a cast using & like (int&). I would not expect to see this or use this in any normal C++ code.

Answer 5

In this particular case the conversion in question has no meaning. It is an attempt to reinterpret memory occupied by a 'float' object and an 'int' Lvalue. This is explicitly illegal in C/C++, meaning that it produces undefined behavior. Undefined behavior - that's the only meaning that it has in this case.

Answer 6

What were you going to do? The same thing:

float b = 1.0f;
int i = (int) b;
int* j = (int*)b;//here we treat b as a pointer to an integer
cout<<i<<endl;
cout<<(*j)<<endl;

How to fix:

float b = 1.0f;
int i = (int) b;
int castedB = (int)b;//static_cast<int>(b);
int& j = castedB;
cout<<i<<endl;
cout<<j<<endl;