Question

Say I have a float that I want to interpret as an unsigned int for some bit-twiddling (let’s assume sizeof(float) == sizeof(int) for now). Now there are various ways that “work”, for example:

float f = 0.5f;
unsigned int u;

u = * (unsigned int*) (&var); /* works in most compilers */

union {
    float f;
    unsigned int u;
} uconv;

uconv.f = f;
u = uconv.u; /* works in most compilers */

Now I don’t know the standard by heart, but IIRC the first is undefined behaviour thanks to the strict aliasing rule and I heard that the latter is undefined behaviour too.

So what is the correct, defined way to interpret the value of one type as if it was another type?

---

Please add to your answer whether it works for C89, C90, C99 or even C11.

Answer 1

In general, the correct way is to cast the variable’s address to void*, char* or unsigned char*, because any other pointer cast may cause undefined behavior (indeed, because of strict aliasing). int* and float* are incompatible pointer types.

When the sizeof both types is the same, the following will work:

memcpy(&u, &var, sizeof(int));  // note: implicit conversion to void [const] *

The value that you get is obviously implementation-defined, since it depends on how both int and float are represented in memory.

Strict aliasing has been around since C89.

EDIT: seems I was wrong previously about the union hack causing UB. The relevant part of the C11 draft states:

If the member used to read the contents of a union object is not the same as the member last used to
store a value in the object, the appropriate part of the object representation of the value is reinterpreted
as an object representation in the new type as described in 6.2.6 (a process sometimes called ‘‘type
punning’’).

— Foonote 95 to 6.5.2.3 Structure and union members