当被除数与除数符号相同时，Divide Overflow（除法溢出）为何会发生？

Great question—this is one of those subtle edge cases that trips up a lot of folks when diving into computer architecture. Let’s break it down clearly, because division overflow isn’t just about dividing by zero (though that’s the case most people learn first).

First: What’s Actually Division Overflow? #

At its core, division overflow happens when the result of a division can’t fit into the target register the CPU is using to store the quotient. Dividing by zero is one obvious trigger, but there’s another critical scenario with signed integers that only occurs when the dividend and divisor have the same sign.

The Edge Case That Causes Same-Sign Overflow #

Let’s use 32-bit signed integers as an example (super common in x86 systems):

• A 32-bit signed int can hold values from -2^31 (that’s -2147483648) up to 2^31 - 1 (2147483647).
• Now take the smallest possible negative value: -2147483648. If you divide this by -1 (same sign as the dividend), the mathematical result is 2147483648. But wait—this number is just barely too big to fit in a 32-bit signed register (since the max positive value is one less than that).

There’s no way to represent that result in the register, so the CPU throws a division overflow exception.

Compare this to an opposite-sign scenario: divide -2147483648 by 1, and you get -2147483648—which fits perfectly as the minimum value of the register. No overflow here.

Why This Only Happens With Same Signs #

For signed division, the only time the quotient exceeds the register’s capacity is when:

• You’re dividing the absolute minimum signed value (the most negative number the register can hold)
• By -1 (so same sign as the dividend)

In every other same-sign division case, the quotient will fit. For example:

• 100 / 2 = 50 (no problem)
• -100 / -2 = 50 (also fits easily)

It’s just that one specific edge case where the math checks out (no division by zero!), but the result can’t be represented in the target register.

Dividing by Zero vs. This Overflow #

Just to avoid confusion: dividing by zero will trigger a division overflow no matter what signs the numbers have. The same-sign overflow we’re talking about is a separate scenario—valid math, but an unrepresentable result.

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