Arithmetic operators and overflow in Swift - Step-by-Step Execution

Concept Flow - Arithmetic operators and overflow

Start with two numbers

↓

Apply arithmetic operator

↓

Check for overflow?

No→Return result

Yes↓

Handle overflow (wrap, trap, or report)

↓

End

This flow shows how Swift performs arithmetic operations and checks if the result fits in the number type, handling overflow if needed.

Execution Sample

Swift

var a: UInt8 = 250
let b: UInt8 = 10
let c = a &+ b

Adds two UInt8 numbers using overflow addition (&+), which wraps around on overflow.

Execution Table

Step	Variable a	Variable b	Operation	Result	Overflow Detected	Action
1	250	10	a &+ b	260 (exceeds 255)	Yes	Wrap around using &+
2	250	10	Wrap 260 to 4 (260 - 256)	4	No	Result stored in c
3	N/A	N/A	End	Final c = 4	N/A	Execution stops

💡 Overflow detected because 260 is greater than UInt8 max 255; wrapping result to 4.

Variable Tracker

Variable	Start	After Operation	Final
a	250	250	250
b	10	10	10
c	N/A	4	4

Key Moments - 2 Insights

Why does the result wrap around instead of causing an error?

Because the &+ operator in Swift performs overflow addition, it wraps the value instead of trapping, as shown in execution_table step 1 and 2.

What happens if we use + instead of &+ when adding 250 and 10?

Using + would cause a runtime error (trap) on overflow, unlike &+ which wraps. This is why &+ is used to allow overflow safely (not shown in table but important).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of c after wrapping?

A 260

B 10

C 4

D 250

💡 Hint

Check the 'Result' column in step 2 where wrapping occurs.

At which step does the overflow get detected?

A Step 3

B Step 1

C Step 2

D No overflow detected

💡 Hint

Look at the 'Overflow Detected' column in the execution table.

If variable a was 100 instead of 250, what would happen to the overflow?

A No overflow would occur

B Overflow would still occur

C Program would crash

D Result would be zero

💡 Hint

Refer to variable_tracker and consider 100 + 10 within UInt8 range.

Concept Snapshot

Swift arithmetic operators like + can trap on overflow.
Use &+ (overflow addition) to wrap values instead.
UInt8 max is 255; adding beyond wraps around.
Overflow operators prevent runtime crashes by wrapping.
Always choose operator based on desired overflow behavior.

Full Transcript

This example shows how Swift handles arithmetic operations with overflow. We start with two UInt8 numbers, 250 and 10. Adding them normally would exceed the maximum value 255 for UInt8. Using the overflow addition operator &+, Swift detects the overflow and wraps the result around, storing 4 instead of causing an error. The execution table traces each step: detecting overflow, wrapping the value, and storing the final result. Variables a and b remain unchanged, while c holds the wrapped result. Key points include understanding the difference between + and &+ operators and how overflow is handled safely in Swift.