指向浮点的短指针

Question

i run this code in c++:

#include <iostream>
using namespace std;
int main()
{
    float f = 7.0;
    short s = *(short *)&f;
    cout << sizeof(float) << endl
         << sizeof(short) << endl
         << s << endl;
    return 0;
}

i get the following out pot:

4
2
0

but, in a lecture given in Stanford university, Professor Jerry Cain says he is sure the out pot well not be 0.

the lecture is can be fond here . he says that around the 48 minute.

is he wrong, or that some standard change since? or is there a difference between platforms?
I'm using g++ to compile my code.

in the next lecture he does mention "big endian" and "small endian" and says that they well affect the result.

Answer 1

static void bitPrint(float f)
{
    assert(sizeof(int) == sizeof(float));
    int *data = reinterpret_cast<int*>(&f);
    for (int i = 0; i < sizeof(int) * 8; ++i)
    {
        int bit = (1 << i) & *data;
        if (bit) bit = 1;
        cout << bit;
    }
    cout << endl;
}

int main()
{
    float f = 7.0;
    bitPrint(f);
    return 0;
}

This program prints 00000000000000000000011100000010

Since the sizeof(short) == 2 on your platform you get the first 2 bytes which are both zeros

Note that since size of types and possibly float implementation (not sure about this) are implementation defined different output can be seen on different platforms.

Answer 2

Well, let's see. First you write a float into the memory. It occupies 4 bytes, and it's value is 7. A float in the memory looks something like "sign bit -> exponent bits -> mantissa bits". I'm not sure how many bits are there for each part exactly, probably that depends on your platform.

Since the float's value is 7, it only occupies some of the least-significant bits on the right (I assume big-endian).

Your short pointer points to the beginning of the float, which means to the most significant bit. Since the value is greater than 0, the sign bit is zero. Since the float value is far on the right, we can say that those two most significant bytes are filled with zeros.

Now, provided that a size of short is 2, which means we will only take two bytes out of float's 4 bytes, we get our 0 .

I believe though, that this result is rather UB and can differ on different platforms, compilers, etc.

Answer 3

Accessing data through a pointer to a different type than it was stored as gives (except in a few special cases) undefined behavour.

Firstly it's platform dependent how the data it stored so different systems may well give different values, and secondly the compiler might well generate code that doesn't even see the value you'd expect as it's allowed to do anything it likes when you do this (It's undefined behavour due to the strict aliases rules).

Having said that there are probably reasons why the number you are seeing is valid, but you can't rely on it unless you specifically know your platform will do what you expect, it's not guarenteed by the standard.

Answer 4

He's "pretty" sure it's not zero, he says that explicitly.

However, given that the representation of a short can be big-endian or little-endian, I wouldn't be so certain. In any case, this is a throwaway line at the end of a fifty-minute lecture so we can forgive him a little. It may be he came back in the next lecture with a clarification.

You would need to examine the underlying bits at (at least) a byte-by-byte level to understand what's going on.