C++ Undefined behaviour with unions

Question

Was just reading about some anonymous structures and how it is isn't standard and some general use case for it is undefined behaviour...

This is the basic case:

struct Point {
    union {
       struct {
           float x, y;
       };
       float v[2];
    };
};

So writing to x and then reading from v[0] would be undefined in that you would expect them to be the same but it may not be so.

Not sure if this is in the standard but unions of the same type...

union{ float a; float b; };

Is it undefined to write to a and then read from b ?

That is to say does the standard say anything about binary representation of arrays and sequential variables of the same type.

Answer 1

The standard says that reading from any element in a union other than the last one written is undefined behavior. In theory, the compiler could generate code which somehow kept track of the reads and writes, and triggered a signal if you violated the rule (even if the two are the same type). A compiler could also use the fact for some sort of optimization: if you write to a (or x), it can assume that you do not read b (or v[0]) when optimizing.

In practice, every compiler I know supports this, if the union is clearly visible, and there are cases in many (most?, all?) where even legal use will fail if the union is not visible (e.g.:

union  U { int i; float f; };

int f( int* pi, int* pf ) { int r = *pi; *pf = 3.14159; return r; }

//  ...
U u;
u.i = 1;
std::cout << f( &u.i, &u.f );

I've actually seen this fail with g++, although according to the standard, it is perfectly legal.)

Also, even if the compiler supports writing to Point::x and reading from Point::v[0], there's no guarantee that Point::y and Point::v[1] even have the same physical address.