为何计算机系统采用补码实现减法？已有减法器为何仍需补码？

Great question—this is one of those fundamental computer architecture details that feels obvious once you wrap your head around it, but trips up a lot of folks at first. Let’s break this down step by step.

The Core Win: Reuse Existing Hardware #

The biggest reason we rely on two's complement for subtraction is hardware efficiency. Building dedicated circuits for every single operation gets costly fast—both in terms of chip real estate and power consumption.

Here’s the trick: with two's complement, subtraction a - b is mathematically equivalent to a + (-b), where -b is the two's complement of b. This means we don’t need a separate subtractor circuit. The same adder that handles 3 + 5 can handle 5 - 3 just by feeding it the complement of 3 instead of 3 itself. That’s a massive simplification for hardware designers—no need to duplicate logic, just repurpose what’s already there.

Why Not Just Use a Dedicated Subtractor? #

You’re right, we could build a subtractor circuit. But subtractors come with their own set of headaches that make two's complement a better choice:

• Extra complexity: Subtractors require additional logic to handle borrow operations, which adds more gates and wiring compared to a basic adder. More gates mean more space, more power, and more potential for errors.
• Redundant hardware: Having separate adders and subtractors wastes precious chip space. For most systems, which handle a mix of addition and subtraction (often more addition), this is inefficient.
• Unified zero representation: Unlike sign-magnitude or one's complement, two's complement has only one way to represent zero (0000...0000). Sign-magnitude has both 0000...0000 (+0) and 1000...0000 (-0), which creates edge cases and extra logic to handle those duplicates.
• Simpler overflow detection: With two's complement, overflow can be detected with a simple check of the carry-in and carry-out of the most significant bit. This is way more straightforward than handling overflow in a dedicated subtractor.

A Quick Example to Make It Concrete #

Let’s use 8-bit two's complement to calculate 5 - 3:

1. 5 in 8-bit binary: 00000101
2. 3 in 8-bit binary: 00000011
3. Two's complement of 3: Flip all bits (11111100) then add 1 → 11111101
4. Add 5 and the complement of 3: 00000101 + 11111101 = 100000010
5. Truncate to 8 bits: 00000010 (which is 2)—exactly the result we want!

This works because two's complement wraps around modulo (2^n) (where n is the number of bits), so subtracting a number is the same as adding its "wrap-around" equivalent.

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