This will never be legal, no matter what kind of contortions you perform with weird casts and unions and whatnot.

The fundamental fact is this: two objects of different type may never alias in memory, with a few special exceptions (see further down).

Example

Consider the following code:

void sum(double& out, float* in, int count) { for(int i = 0; i < count; ++i) { out += *in++; } }

Let's break that out into local register variables to model actual execution more closely:

void sum(double& out, float* in, int count) { for(int i = 0; i < count; ++i) { register double out_val = out; // (1) register double in_val = *in; // (2) register double tmp = out_val + in_val; out = tmp; // (3) in++; } }

Suppose that (1), (2) and (3) represent a memory read, read and write, respectively, which can be very expensive operations in such a tight inner loop. A reasonable optimization for this loop would be the following:

void sum(double& out, float* in, int count) { register double tmp = out; // (1) for(int i = 0; i < count; ++i) { register double in_val = *in; // (2) tmp = tmp + in_val; in++; } out = tmp; // (3) }

This optimization reduces the number of memory reads needed by half and the number of memory writes to 1. This can have a huge impact on the performance of the code and is a very important optimization for all optimizing C and C++ compilers.

Now, suppose that we don't have strict aliasing. Suppose that a write to an object of any type can affect any other object. Suppose that writing to a double can affect the value of a float somewhere. This makes the above optimization suspect, because it's possible the programmer has in fact intended for out and in to alias so that the sum function's result is more complicated and is affected by the process. Sounds stupid? Even so, the compiler cannot distinguish between "stupid" and "smart" code. The compiler can only distinguish between well-formed and ill-formed code. If we allow free aliasing, then the compiler must be conservative in its optimizations and must perform the extra store (3) in each iteration of the loop.

Hopefully you can see now why no such union or cast trick can possibly be legal. You cannot circumvent fundamental concepts like this by sleight of hand.

Exceptions to strict aliasing

The C and C++ standards make special provision for aliasing any type with char , and with any "related type" which among others includes derived and base types, and members, because being able to use the address of a class member independently is so important. You can find an exhaustive list of these provisions in this answer.

Furthermore, GCC makes special provision for reading from a different member of a union than what was last written to. Note that this kind of conversion-through-union does not in fact allow you to violate aliasing. Only one member of a union is allowed to be active at any one time, so for example, even with GCC the following would be undefined behavior:

union { double d; float f[2]; }; f[0] = 3.0f; f[1] = 5.0f; sum(d, f, 2); // UB: attempt to treat two members of // a union as simultaneously active

Workarounds

The only standard way to reinterpret the bits of one object as the bits of an object of some other type is to use an equivalent of memcpy . This makes use of the special provision for aliasing with char objects, in effect allowing you to read and modify the underlying object representation at the byte level. For example, the following is legal, and does not violate strict aliasing rules:

int a[2]; double d; static_assert(sizeof(a) == sizeof(d)); memcpy(a, &d, sizeof(d));

This is semantically equivalent to the following code:

int a[2]; double d; static_assert(sizeof(a) == sizeof(d)); for(size_t i = 0; i < sizeof(a); ++i) ((char*)a)[i] = ((char*)&d)[i];

GCC makes a provision for reading from an inactive union member, implicitly making it active. From the GCC documentation:

The practice of reading from a different union member than the one most recently written to (called “type-punning”) is common. Even with -fstrict-aliasing, type-punning is allowed, provided the memory is accessed through the union type. So, the code above will work as expected. See Structures unions enumerations and bit-fields implementation. However, this code might not:

int f() { union a_union t; int* ip; t.d = 3.0; ip = &t.i; return *ip; }

Similarly, access by taking the address, casting the resulting pointer and dereferencing the result has undefined behavior, even if the cast uses a union type, e.g.:

int f() { double d = 3.0; return ((union a_union *) &d)->i; }

Placement new

(Note: I'm going by memory here as I don't have access to the standard right now). Once you placement-new an object into a storage buffer, the lifetime of the underlying storage objects ends implicitly. This is similar to what happens when you write to a member of a union:

union { int i; float f; } u; // No member of u is active. Neither i nor f refer to an lvalue of any type. u.i = 5; // The member u.i is now active, and there exists an lvalue (object) // of type int with the value 5. No float object exists. u.f = 5.0f; // The member u.i is no longer active, // as its lifetime has ended with the assignment. // The member u.f is now active, and there exists an lvalue (object) // of type float with the value 5.0f. No int object exists.

Now, let's look at something similar with placement-new:

#define MAX_(x, y) ((x) > (y) ? (x) : (y)) // new returns suitably aligned memory char* buffer = new char[MAX_(sizeof(int), sizeof(float))]; // Currently, only char objects exist in the buffer. new (buffer) int(5); // An object of type int has been constructed in the memory pointed to by buffer, // implicitly ending the lifetime of the underlying storage objects. new (buffer) float(5.0f); // An object of type int has been constructed in the memory pointed to by buffer, // implicitly ending the lifetime of the int object that previously occupied the same memory.

This kind of implicit end-of-lifetime can only occur for types with trivial constructors and destructors, for obvious reasons.