Why would someone use this type of cast in C? The reference of a float is cast to an int pointer and then dereferenced

Question

I was reading about Carmack's fast inverse square root algorithm and noticed this:

float x;
// ... //
int i = *(int*)&x;

Why would someone choose to use this weird type of casting instead of just the following?

int i = (int)x;

Answer 1

That's different.

int i = (int) x; will cast float to int, which will simply truncate it.

int i = *(int *) &x; will load into i the same bits that are currently stored in x. The result is something totally different from truncating x.

Answer 2

It's called type punning. It'll interpret the float as an int. Meaning, the bit representation is exactly copied.

It's a potentially dangerous operation, since some bit representations of floating point integers might be trap representations as integers (not the case with IEEE-754 floats and 2s complement integers, though).

Additionally, it might not work anymore, due to being undefined behaviour as per C standard. It's violating the strict aliasing rule.

C only supports accessing variable of a different type via memcpy.

This is the valid standard C way of writing the operation:

int y; float x = 42.0f;
memcpy(&y, &x, sizeof(x));

C99 added another way of doing this, by using a union:

union { int y; float x; } u = { .x = 42.0f };
int y = u.y;