C语言中*((int*)&f)的作用解析——浮点数转二进制实现疑问

Hey there! Let's unpack that line of code you're curious about—it's a clever (but sometimes tricky) way to grab the raw binary representation of a float by treating its memory as an int. Here's a step-by-step breakdown to make it crystal clear:

1. The core premise: Matching memory footprints #

First, a quick reminder: On most modern systems, a float uses exactly 4 bytes of memory (following the IEEE 754 single-precision standard), and a standard int also occupies 4 bytes. This means both types take up the same amount of space in memory—we just need to tell the compiler to interpret that same block of memory differently.

2. Breaking down each piece of *((int*)&f) #

Let's split the line into small, digestible parts:

• &f: This grabs the memory address of your float variable f. The result is a pointer of type float* (a pointer pointing to a float).
• (int*)&f: Here we do a type cast—we’re telling the compiler, "Hey, treat this float* pointer like it’s an int* (a pointer to an integer)." This doesn’t change the actual memory address, just how the compiler thinks about the data stored there.
• *((int*)&f): Finally, we dereference the cast pointer. This means we read the 4 bytes of memory starting at that address, but instead of interpreting them as a float value, we read them as an integer.

3. Why this works for binary conversion #

When you convert this resulting integer to a binary string, you’re getting the exact sequence of bits the float uses to store its value (including the sign bit, exponent, and mantissa defined by the IEEE 754 standard).

This is totally different from a simple cast like (int)f—that converts the numerical value of the float to an integer (e.g., 0.5f becomes 0), whereas we want the raw binary bits of the float itself.

4. A few quick caveats to keep in mind #

• This relies on float and int being the same size (4 bytes). On rare systems where int is 2 bytes, this will break. For 64-bit systems working with double, you’d use long long instead of int since double takes up 8 bytes.
• Byte order (endianness) might change the integer value you get, but the raw bit sequence (when converted properly) will still accurately represent the original float.

As an example: If f = 0.5f, its IEEE 754 hex representation is 0x3F000000. The line *((int*)&f) will return the integer 0x3F000000, which you can convert to the binary string 00111111000000000000000000000000—the exact binary of the float.

内容的提问来源于stack exchange，提问作者Pahasa