Question

Unions aren’t something I’ve used that often and after looking at a few other questions on them here it seems like there is almost always some kind of caveat where they might not work. Eg. structs possibly having unexpected padding or endian differences.

Came across this in a math library I’m using though and I wondered if it is a totally safe usage. I assume that multidimensional arrays don’t have any extra padding and since the type is the same for both definitions they are guaranteed to take up exactly the same amount of memory?

template<typename T> class Matrix44T
{
    ...

    union
    {
        T M[16];
        T m[4][4];
    } m;
};

Are there any downsides to this setup? Would the order of definition make any difference to how this works?

Answer 1

Although I do exactly the same in my Matrix-class I think this is implementation dependent, reading the standard to the letter:

Standard 9.5.1:

In a union, at most one of the data
members can be active at any time,
that is, the value of at most one of
the data members can be stored in a
union at any time. [Note: one special
guarantee is made in order to simplify
the use of unions: If a POD-union
contains several POD-structs that
share a common initial sequence (9.2),
and if an object of this POD-union
type contains one of the POD-structs,
it is permitted to inspect the common
initial sequence of any of POD-struct
members; see 9.2. ]

The question then is do m and M share a common initial sequence, to answer this we look at 9.2/15:

Two POD-union (clause 9) types are
layout-compatible if they have the
same number of nonstatic data members,
and corresponding nonstatic data
members (in any order) have
layout-compatible types (3.9).

After reading this the answer seems to be, no m and M are not layout-compatible in the strict sense of the word.

In practice I think this will work fine on all compilers though.