C语言整数操作的未定义行为及跨平台确定性操作问询

Great question—this is exactly the kind of detail that separates robust, portable C code from stuff that breaks the second you switch compilers or architectures. Let's break down each operation category one by one, focusing only on behavior the C standard guarantees across all conforming implementations.

1. Truncation (Converting to a Smaller Integer Type) #

Truncation happens when you cast a larger integer type to a smaller one. The rules split cleanly between signed and unsigned targets:

• Unsigned target type: The result is always the source value modulo 2^N, where N is the number of bits in the target type. This is 100% deterministic across all platforms.
  Example: (uint8_t)300 evaluates to 300 % 256 = 44.
• Signed target type: If the source value fits within the target type's range, the result is the same as the source. If it doesn't fit, this is implementation-defined behavior (not undefined, but still not portable—different compilers/architectures may return different values or even throw a signal). You should never rely on this for cross-platform code.

2. Extension (Converting to a Larger Integer Type) #

Extension is when you cast a smaller integer type to a larger one. The standard guarantees two specific behaviors:

• Unsigned source type: Always zero-extended—high-order bits are filled with 0, regardless of whether the target is signed or unsigned. This is portable.
  Example: (uint32_t)0xFF becomes 0x000000FF; (int32_t)0xFF also becomes 0x000000FF (since 255 fits within the range of a 32-bit int).
• Signed source type: When converting to a larger signed type, always sign-extended—high-order bits are filled with the source's sign bit. This preserves the original value's sign and magnitude.
  Example: (int32_t)(int8_t)-1 becomes 0xFFFFFFFF (which represents -1 in 32-bit two's complement, the most common signed representation, but the standard guarantees this works even if the architecture uses one's complement or sign-magnitude).

3. Comparison Operations #

Comparisons behave predictably as long as you account for mixed-type rules:

• Same-type comparisons: Fully deterministic. For signed types, comparisons follow mathematical integer rules; for unsigned types, they follow modulo 2^N ordering.
  Examples:
  • (int)-1 < (int)0 is true
  • (uint32_t)-1 < (uint32_t)0 is false (since -1 cast to uint32_t is 4294967295)
• Mixed signed/unsigned comparisons: The standard triggers usual arithmetic conversions: the signed operand is converted to the unsigned type, then the comparison proceeds as unsigned. This is fully portable.
  Example: (int)-1 < (uint32_t)0 is false—the -1 becomes 4294967295, which is larger than 0.

4. Signed ↔ Unsigned Conversions #

Beyond truncation/extension, here are the core guaranteed rules:

• Signed to unsigned: Always computed as the source value modulo 2^N (N = target's bit count). This works even if the source is negative.
  Example: (uint16_t)-5 is 65536 - 5 = 65531
• Unsigned to signed: If the unsigned value fits within the signed target's range, the result is the same as the source. If it doesn't fit, this is implementation-defined behavior—avoid this for portable code.

5. Arithmetic Operations #

Arithmetic rules split sharply between signed and unsigned:

• Unsigned arithmetic: All operations are performed modulo 2^N (N = operand's bit count). "Overflow" is defined as part of this modulo behavior, so it's never undefined—just predictable.
  Example: (uint8_t)255 + (uint8_t)1 evaluates to 0 (256 mod 256 = 0)
• Signed arithmetic: If the result fits within the type's range, it follows mathematical integer rules (portable). If it overflows, this is undefined behavior—the standard allows anything to happen (crash, wrong value, etc.). Never rely on signed overflow behavior.
• Mixed signed/unsigned arithmetic: Usual arithmetic conversions apply: the signed operand is converted to unsigned, then the operation proceeds as unsigned arithmetic (modulo 2^N). This is portable.
  Example: (int)-1 + (uint8_t)1 evaluates to 0 (-1 becomes 255, 255+1=256 mod 256=0)

Quick Cheat Sheet: Portable vs. Non-Portable #

Always Portable (Guaranteed by C Standard)

• All unsigned type conversions, arithmetic, and comparisons
• Sign-extending signed types to larger signed types
• Zero-extending unsigned types to any larger type
• Same-type comparisons (signed or unsigned)
• Mixed-type comparisons/arithmetic (signed → unsigned conversion first)
• Signed → unsigned conversion via modulo 2^N
• Signed arithmetic where results fit within the type's range

Non-Portable (Avoid for Cross-Platform Code)

• Signed → smaller signed conversion when source is out of range (implementation-defined)
• Unsigned → signed conversion when source is out of range (implementation-defined)
• Signed arithmetic overflow (undefined behavior)

Sticking to these guaranteed behaviors is exactly how you write C code that works everywhere—nice job prioritizing portability over relying on platform-specific quirks!

内容的提问来源于stack exchange，提问作者J.Doe