reinterpret_casthandle that for me?
One reason is that the size, alignment, and bit representations aren’t specified, so such a conversion wouldn’t be portable. However, that wouldn’t really justify making the behaviour undefined, just implementation-defined.
By making it undefined, the compiler is allowed to assume that expressions of unrelated types don’t access the same object, which can allow better optimisation. For example, in the following:
int & i = something(); float & f = something_else(); const int i1 = i; f = 42; const int i2 = i;
the compiler can assume that
i2 both have the same value (
i being unchanged by the assignment to
f), and optimise them into a single constant. Breaking the assumption will then cause undefined behaviour.
Or is there something else available so I don’t have to jump through this hoop?
Copying the bytes is the only well-defined way to reinterpret one object type as an unrelated type.
reinterpret_cast or a union might work sometimes (assuming the size etc. match), but might trip you up if the optimiser gets too clever with undefined behaviour.