Swift Academy · Lesson

Stack vs Heap: Where Values Live

How structs live on the stack and classes on the heap, and the performance implications.

Lesson 1 of 412 steps

Stack vs Heap: Where Values Live is a free Swift Academy lesson on CoddyKit. This is lesson 1 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

Welcome

Understanding where Swift values live in memory — the stack vs the heap — is essential for writing performant, predictable code.

The Stack

The stack is a contiguous block of memory managed automatically: • Function locals and parameters live here • Allocation is O(1) — just move a pointer • Automatically freed when the scope exits • Thread-local — each thread has its own stack

The Heap

The heap is a shared pool for long-lived allocations: • Objects live here when their lifetime extends beyond one scope • Allocation requires finding free memory — more expensive • Managed by ARC for classes • Shared across threads — requires synchronisation

Structs Live on the Stack

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Small structs are passed by copy — zero heap overhead.

Classes Live on the Heap

```swift class Dog { var name: String init(name: String) { self.name = name } } var d = Dog(name: "Rex") // Dog instance on heap // 'd' is a pointer on the stack ```

Large Structs May Use the Heap

Large structs (arrays, strings, large value types) use COW and heap storage internally even though they behave as value types: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Capture in Closures

When a closure captures a value-type variable that must outlive the scope, Swift boxes it on the heap: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Protocol Existential Boxing

Storing small value types in `any Protocol` variables can cause heap allocation (existential boxing): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` Small types (≤3 words) are inlined; larger types are boxed.

Measuring Allocations

Use Instruments Allocations template to see heap allocations: 1. Profile > Allocations 2. Filter by class or category 3. Track `alloc` vs `dealloc` counts High alloc counts in loops often indicate unexpected boxing.

Design Implications

• Prefer structs for short-lived data-holding types — stack speed • Use classes when identity or shared state is needed • Avoid allocating in tight loops — pre-allocate with `reserveCapacity` • Profile before optimising — premature optimisation wastes time

Quick Check

Which type of memory is automatically freed when a function scope exits?

Answer it in the interactive lesson

Recap

Key takeaways: • Stack: cheap, automatic, thread-local, value types • Heap: flexible, ARC-managed, reference types • Large structs use internal heap buffers (COW) • Closures that capture variables box them on the heap • Use Instruments Allocations to detect unexpected heap pressure Next: mutation, sharing, and unexpected aliasing.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “Stack vs Heap: Where Values Live” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “Stack vs Heap: Where Values Live”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

What will I learn in “Stack vs Heap: Where Values Live”?

How structs live on the stack and classes on the heap, and the performance implications. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners, so you can start here or from the beginning and move at your own pace. This is lesson 1 of 4.

How long does the “Stack vs Heap: Where Values Live” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Stack vs Heap: Where Values Live
Mutation, Sharing and Unexpected Aliasing
Mixed Value/Reference Graphs
Designing APIs for Value Semantics

← Back to Swift Academy