Signed vs Unsigned Integers

When you write int x = -5; in code, have you ever paused to consider how the computer understands that this value is negative? At the hardware level, computers only have two states—on and off, 1 and 0. There's no special "negative bit" or "minus symbol" stored in silicon. So how do we represent negative numbers using only binary?

This seemingly simple question leads to one of the most fundamental concepts in computer science: the distinction between signed and unsigned integers. Understanding this distinction is not merely academic—it directly impacts the correctness, security, and efficiency of the software you write.

Let's start with a fundamental observation: binary numbers, by their natural mathematical definition, can only represent non-negative values. A sequence like 1011 directly maps to the decimal value 11 through positional notation:

$$1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 1 \times 2^0 = 8 + 0 + 2 + 1 = 11$$

Every bit contributes a positive power of 2. There's no inherent way to produce a negative result from this scheme. Yet programming requires negative numbers constantly—financial calculations, temperature readings, coordinate systems, and countless other domains depend on values below zero.

The challenge: Given a fixed number of bits (say, 32 bits), how do we encode both positive and negative values within the same bit space?

The fundamental trade-off:

If you have n bits, you can represent exactly $2^n$ distinct values. With 8 bits, that's 256 distinct patterns. The question becomes: how do you allocate these 256 patterns?

• Unsigned approach: Use all 256 patterns for non-negative values: 0 through 255
• Signed approach: Split the patterns between negative and non-negative values

This is the essence of the signed vs unsigned distinction. It's not about storing different data—it's about interpreting the same bit patterns differently.

Unsigned integers follow the straightforward positional binary interpretation. Every bit pattern maps directly to its mathematical binary value, and all representable values are non-negative.

The range formula for unsigned integers:

For an n-bit unsigned integer:

• Minimum value: 0
• Maximum value: $2^n - 1$

When to use unsigned integers:

Unsigned types are appropriate when values are inherently non-negative and you want to maximize the positive range:

• Array indices and sizes — An array cannot have negative length
• Counts and quantities — You can't have -5 users
• Memory addresses — Addresses are always positive offsets
• Bit manipulation — When treating integers as bit patterns rather than numeric values
• Cryptographic operations — Where modular arithmetic on full-width values is expected

Before we examine the modern standard, it's instructive to understand the historical approaches to representing signed integers. Each approach has different trade-offs, and understanding why they were abandoned illuminates the elegance of the modern solution.

Why sign-magnitude failed:

1. Two representations of zero: 00000000 (+0) and 10000000 (-0) both represent zero, wasting a bit pattern and complicating equality comparisons.

2. Complex arithmetic circuits: Adding a positive and negative number requires different logic than adding two positives. The CPU needs to check signs, possibly swap operands, subtract magnitudes, and determine the result sign—significantly more hardware.

3. Subtraction is not just negation plus addition: The hardware complexity increases substantially.

Why one's complement failed:

1. Still two zeros: 00000000 (+0) and 11111111 (-0) both represent zero.

2. End-around carry: Addition sometimes requires an "end-around carry" where the overflow bit must be added back to the result—additional hardware complexity.

Both approaches were actually used in early mainframes. The UNIVAC 1100 series used one's complement, while early IBM systems used sign-magnitude. The industry converged on two's complement because it solves all these problems elegantly.

Two's complement is the universal standard for representing signed integers in modern computers. Nearly every processor—from embedded microcontrollers to supercomputers—uses two's complement for signed integer arithmetic.

The definition:

To find the two's complement representation of a negative number:

1. Start with the binary representation of the positive magnitude
2. Invert (flip) all bits
3. Add 1 to the result

Example: Representing -5 in 8-bit two's complement

1. Start with +5: 00000101
2. Invert all bits: 11111010
3. Add 1: 11111011

Therefore, -5 in 8-bit two's complement is 11111011.

Key observations:

1. The sign bit: The most significant bit (MSB) indicates the sign: 0 for non-negative, 1 for negative. But unlike sign-magnitude, this bit also contributes to the numeric value.

2. Only one zero: The pattern 00000000 uniquely represents zero. There's no wasted "negative zero."

3. Asymmetric range: The range is -128 to +127 for 8 bits, not -127 to +127. There's one more negative value than positive values.

4. Wraparound behavior: If you increment 01111111 (+127), you get 10000000 (-128). The number "wraps around" from the maximum positive to the minimum negative.

Two's complement isn't just a clever encoding trick—it has deep mathematical properties that make it ideal for hardware implementation.

Interpretation formula:

For an n-bit two's complement number with bits $b_{n-1}b_{n-2}...b_1b_0$:

$$\text{value} = -b_{n-1} \times 2^{n-1} + \sum_{i=0}^{n-2} b_i \times 2^i$$

The most significant bit contributes negative $2^{n-1}$ instead of positive. This single change transforms unsigned into signed interpretation.

Example: Interpreting 11111011 (8-bit)

$$= -1 \times 2^7 + 1 \times 2^6 + 1 \times 2^5 + 1 \times 2^4 + 1 \times 2^3 + 0 \times 2^2 + 1 \times 2^1 + 1 \times 2^0$$ $$= -128 + 64 + 32 + 16 + 8 + 0 + 2 + 1$$ $$= -128 + 123 = -5$$

Why the same hardware works for both signed and unsigned addition:

Consider adding two 8-bit numbers. The CPU performs binary addition with carry propagation:

  00000101  (5)
+ 11111011  (-5 signed, or 251 unsigned)
─────────────
  00000000  (0 signed, or 0 unsigned modulo 256)

The hardware doesn't "know" if these are signed or unsigned—it just adds bits. The result is correct for both interpretations:

• Signed: 5 + (-5) = 0 ✓
• Unsigned: (5 + 251) mod 256 = 256 mod 256 = 0 ✓

This unification of addition logic is why two's complement won. It halves the complexity of arithmetic circuits.

The choice between signed and unsigned affects the range of representable values. Both use the same number of bits, but they interpret those bits differently.

General formulas:

For n bits:

The asymmetry in signed ranges:

Notice that signed ranges have one more negative value than positive. For 8-bit signed: -128 to +127 (not -127 to +127). This is because zero takes one of the "non-negative" patterns, leaving one extra pattern for negatives.

This asymmetry matters: you cannot negate the minimum signed value within the same type. In 8-bit signed, -(-128) cannot be represented as +128 because +128 exceeds the maximum (+127). In most systems, -(-128) = -128 due to overflow—a subtle source of bugs.

The signed/unsigned distinction affects how operations behave, often in subtle ways that cause bugs.