Binary Addition, Logical Shifts, and Overflow

Hello. In the previous lesson, you converted between denary, binary, and hexadecimal, using binary place values such as $128,64,32,\dots ,1$. Now you will use those same place values to calculate with binary.

This lesson covers binary addition, logical left and right shifts, and overflow when a result cannot fit in the fixed number of bits available. At O Level, questions commonly use eight-bit unsigned binary values, so we will use that format throughout.

---

Binary addition: the same principle, a different base

Addition works in any place-value system. In denary, when a column totals $10$ or more, we write a digit and carry into the next column. In binary, each column can contain only $0$ or $1$, so carrying happens much sooner.

There are four rules to memorise:

Binary calculation	Result written	Carry
$0+0$	$0$	none
$0+1$ or $1+0$	$1$	none
$1+1$	$0$	$1$
$1+1+1$	$1$	$1$

The last two rules make sense when checked in denary:

$$1+1=2_{10}=10_2$$

So write $0$ in the current column and carry $1$ into the next column to the left.

Similarly:

$$1+1+1=3_{10}=11_2$$

So write $1$ and carry $1$.

Always add from right to left, beginning at the least significant bit (LSB).

Worked example: addition within eight bits

Calculate:

$$00101101_2+00011011_2$$

Write the values in aligned columns:

$$\begin{array}{r}00101101\\ +00011011\\ 01001000\end{array}$$

The answer is:

$$01001000_2$$

A denary check confirms this:

$$00101101_2=45_{10}$$ $$00011011_2=27_{10}$$ $$45+27=72$$ $$01001000_2=64+8=72_{10}$$

The important point is that carries are not special “binary tricks.” They follow naturally from the fact that binary is base $2$.

---

Fixed width and overflow in addition

A binary answer only overflows when there is a limit on the number of bits that can be stored.

For an unsigned eight-bit value:

$$00000000_2=0_{10}$$

and the greatest possible value is:

$$11111111_2=255_{10}$$

In general, an unsigned $n$-bit value can represent values from $0$ to:

$$2^n-1$$

If an addition produces a ninth bit, it cannot be stored in an eight-bit location. That lost carry is called overflow.

Worked example: overflow

Add:

$$11111110_2+00000010_2$$

Mathematically, the full answer is:

$$\begin{array}{r}11111110\\ +00000010\\ 100000000\end{array}$$

The full answer needs nine bits:

$$100000000_2=256_{10}$$

But if only eight bits are available, the leftmost $1$ cannot be stored. The stored result is therefore:

$$00000000_2$$

This is overflow. It does not mean that $254+2=0$; it means that the hardware lacked enough bits to store the correct result.

For unsigned addition, use either of these equivalent checks:

• A carry leaves the most significant bit (MSB).
• The denary total is greater than $255$ for eight-bit values.

Keep the specified bit width in your final answer. Writing only $100000000_2$ when the question requires an eight-bit result misses the practical consequence: overflow.

Exam language: “Overflow occurs because the result requires nine bits, but only eight bits are available” is a precise explanation.

---

Logical binary shifts

A logical shift moves every bit a stated number of positions and fills newly empty positions with $0$.

For this lesson, numbers are unsigned: they represent only zero or positive values. Later, signed values use two’s complement and require a different interpretation.

The two directions are:

Shift	What happens	Numerical effect, if no important bit is lost
Logical left shift	Bits move towards the MSB; zeros enter at the right	Multiply by $2$ for each place
Logical right shift	Bits move towards the LSB; zeros enter at the left	Divide by $2$ for each place, discarding any remainder

The multiplication and division effects follow directly from place value. Moving a $1$ from the $8$ column to the $16$ column doubles its contribution. Moving it from $16$ to $8$ halves it.

Logical left shift

Consider the eight-bit value:

$$00101000_2=40_{10}$$

A logical left shift by one place gives:

$$00101000_2\text{ shifted left by 1}=01010000_2$$

The new value is:

$$01010000_2=80_{10}$$

Thus:

$$40\times 2=80$$

A left shift by two places multiplies by $4$, provided the result still fits:

$$00101000_2\text{ shifted left by 2}=10100000_2$$ $$40\times 4=160$$

More generally, shifting left by $k$ places multiplies by:

$$2^k$$

However, this rule is valid only when no $1$ bit is shifted out of the left side.

Overflow in a left shift

Now shift this eight-bit number left once:

$$10110010_2=178_{10}$$ $$10110010_2\text{ shifted left by 1}=01100100_2$$

A $1$ was removed from the MSB, so overflow has occurred.

Mathematically, doubling $178$ gives:

$$178\times 2=356$$

But $356$ is outside the unsigned eight-bit range of $0$ to $255$. The computer retains only the eight bits that fit:

$$01100100_2=100_{10}$$

The stored answer is therefore not the true doubled value.

For a left shift of $k$ places, inspect the leftmost $k$ original bits:

• If they are all $0$, no overflow occurs.
• If any one of them is $1$, that bit will be lost, so overflow occurs.

---

Logical right shift

In a logical right shift, every bit moves towards the LSB. A $0$ is inserted at the MSB end.

Start with:

$$00101000_2=40_{10}$$

Shift right once:

$$00101000_2\text{ shifted right by 1}=00010100_2$$ $$00010100_2=20_{10}$$

So the value has been divided by $2$:

$$40÷2=20$$

A two-place right shift divides by $4$. For example:

$$11001000_2=200_{10}$$ $$11001000_2\text{ shifted right by 2}=00110010_2$$ $$00110010_2=50_{10}$$ $$200÷4=50$$

Right shifts can discard a remainder

Unlike left shifting, a right shift can lose information from the right side. Consider:

$$00101001_2=41_{10}$$

Shift right once:

$$00101001_2\text{ shifted right by 1}=00010100_2$$

The last $1$ has been discarded:

$$00010100_2=20_{10}$$

Yet:

$$41÷2=20.5$$

Binary integers cannot store the fractional part in this format, so the result becomes $20$. In effect, a logical right shift performs whole-number division by a power of $2$, discarding any remainder.

Do not call this overflow. In the O Level context, overflow refers to a $1$ being lost from the MSB during a left shift, or to a calculation needing more bits than are available.

---

A reliable exam method

For any question involving binary addition or shifts, use this sequence.

1. Identify the width. If the question says eight bits, keep exactly eight result bits.
2. For addition, align the LSBs and work right to left, recording carries carefully.
3. For a left shift, move bits left, insert zeros at the right, and check whether a $1$ left the MSB.
4. For a right shift, move bits right, insert zeros at the left, and note whether a $1$ was discarded from the LSB end.
5. Check in denary when time permits. This is particularly useful for detecting an unexpected overflow.

Here is a compact summary.

Operation	Eight-bit example	Result	Key issue
Addition without overflow	$00101101_2+00011011_2$	$01001000_2$	All carries fit
Addition with overflow	$11111110_2+00000010_2$	$00000000_2$ stored	Carry beyond eighth bit
Left shift by one	$00101000_2$	$01010000_2$	Multiplies by $2$
Left shift with overflow	$10110010_2$	$01100100_2$	A $1$ leaves the MSB
Right shift by one	$00101001_2$	$00010100_2$	LSB $1$ is lost; remainder discarded

---

Key takeaways

Binary addition uses four rules:

$$0+0=0,0+1=1,1+1=10,1+1+1=11$$

Add from right to left and carry exactly as in denary, but at a total of $2$ rather than $10$.

For unsigned eight-bit values, the available range is:

$$0\text{ to }255$$

An addition overflows when it produces a carry beyond the eighth bit. A logical left shift overflows when a $1$ is shifted out from the MSB.

Logical shifts insert zeros:

• a left shift by $k$ places multiplies by $2^k$, unless overflow occurs;
• a right shift by $k$ places divides by $2^k$, discarding any fractional remainder.

The next Computer Science lesson extends binary representation to signed integers using two’s complement, where the leftmost bit has a new role.