Why doesn’t this reinterpret_cast compile?

I understand that reinterpret_cast is dangerous, I’m just doing this to test it. I have the following code:

int x = 0;
double y = reinterpret_cast<double>(x);

When I try to compile the program, it gives me an error saying

invalid cast from type ‘float’ to type ‘double

What’s going on? I thought reinterpret_cast was the rogue cast that you could use to convert apples to submarines, why won’t this simple cast compile?


Perhaps a better way of thinking of reinterpret_cast is the rouge operator that can “convert” pointers to apples as pointers to submarines.

By assigning y to the value returned by the cast you’re not really casting the value x, you’re converting it. That is, y doesn’t point to x and pretend that it points to a float. Conversion constructs a new value of type float and assigns it the value from x. There are several ways to do this conversion in C++, among them:

int main()
    int x = 42;
    float f = static_cast<float>(x);
    float f2 = (float)x;
    float f3 = float(x);
    float f4 = x;
    return 0;

The only real difference being the last one (an implicit conversion) will generate a compiler diagnostic on higher warning levels. But they all do functionally the same thing — and in many case actually the same thing, as in the same machine code.

Now if you really do want to pretend that x is a float, then you really do want to cast x, by doing this:

#include <iostream>
using namespace std;

int main()
    int x = 42;
    float* pf = reinterpret_cast<float*>(&x);
    cout << *pf;
    return 0;

You can see how dangerous this is. In fact, the output when I run this on my machine is 1, which is decidedly not 42+1.

Leave a Reply

Your email address will not be published. Required fields are marked *