Why structs are preferred in Swift - Why It Works This Way

Overview - Why structs are preferred in Swift

What is it?

In Swift, structs are a way to group related data and functions together. They are value types, which means each instance keeps its own copy of data. Swift prefers structs for many tasks because they are simple, safe, and efficient. They help developers write clear and predictable code.

Why it matters

Structs help avoid common bugs caused by shared data changes because each copy is independent. Without structs, programs might have confusing side effects when data changes unexpectedly. Using structs makes apps faster and more reliable, especially on devices like iPhones where performance and safety are crucial.

Where it fits

Before learning why structs are preferred, you should understand basic Swift types like classes and value vs reference types. After this, you can explore advanced Swift features like protocols, generics, and memory management to see how structs fit into bigger Swift programming patterns.

Mental Model

Core Idea

Structs are preferred in Swift because they create independent copies of data, making code safer and more predictable.

Think of it like...

Imagine making photocopies of a recipe card to share with friends. Each friend has their own copy to write notes on without changing the original. Structs work like these copies, so changes don’t affect others.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│ Original    │──────▶│ Copy 1      │       │ Copy 2      │
│ Struct Data │       │ Struct Data │       │ Struct Data │
└─────────────┘       └─────────────┘       └─────────────┘
Each box holds its own data copy, changes here don’t affect others.

Build-Up - 6 Steps

1

Foundation

Understanding Value Types Basics

Concept: Learn what value types are and how structs fit this category in Swift.

In Swift, value types store data directly. When you assign or pass a value type, Swift copies the data. Structs are value types, so each variable or constant has its own copy. This is different from classes, which are reference types sharing the same data.

Result

Assigning a struct to a new variable creates a separate copy.

Understanding value types is key because it explains why structs behave independently and avoid unintended data sharing.

2

Foundation

Basic Struct Syntax and Usage

Concept: Learn how to define and use a struct in Swift.

You define a struct with the 'struct' keyword, then list properties and methods inside. For example: struct Point { var x: Int var y: Int } You can create instances like 'let p1 = Point(x: 3, y: 4)'. Each instance holds its own x and y values.

Result

You can create and use multiple independent struct instances.

Knowing how to create structs is the foundation for using their value-type benefits in your code.

3

Intermediate

Copy Behavior and Mutability

🤔Before reading on: Do you think changing one struct copy affects others? Commit to yes or no.

Concept: Explore how copying structs works and how mutability affects them.

When you assign a struct to a new variable, Swift copies all its data. Changing one copy does not change the other. Also, if a struct instance is declared with 'let', it is immutable and cannot be changed. With 'var', you can modify its properties.

Result

Modifying one struct copy leaves other copies unchanged.

Understanding copy-on-assignment and mutability helps prevent bugs from unexpected shared changes.

4

Intermediate

Performance Benefits of Structs

🤔Before reading on: Do you think structs are slower or faster than classes in Swift? Commit to your answer.

Concept: Learn why structs can be more efficient than classes in many cases.

Structs are stored on the stack, which is faster to access than the heap where classes live. Copying small structs is cheap and avoids the overhead of reference counting used by classes. This makes structs ideal for lightweight data like points, colors, or simple models.

Result

Using structs can improve app speed and reduce memory overhead.

Knowing the performance difference guides you to choose structs for better efficiency in many scenarios.

5

Advanced

Safety and Predictability with Value Semantics

🤔Before reading on: Do you think shared references or independent copies lead to safer code? Commit to your answer.

Concept: Understand how structs help avoid bugs by isolating data changes.

Because structs copy data, changes in one place don’t affect others. This eliminates bugs caused by unexpected shared state, common in reference types. Value semantics make reasoning about code easier and safer, especially in concurrent or complex apps.

Result

Code using structs is more predictable and less error-prone.

Recognizing how value semantics improve safety helps you write more reliable Swift programs.

6

Expert

When Structs Are Preferred Over Classes

🤔Before reading on: Do you think structs can fully replace classes in Swift? Commit to yes or no.

Concept: Learn the design philosophy and tradeoffs behind preferring structs in Swift.

Swift encourages structs for most data because they are simpler and safer. Classes are reserved for cases needing inheritance or shared mutable state. This design reduces complexity and bugs. However, structs have limits like no inheritance and copying cost for large data, so classes still have their place.

Result

You understand when to choose structs or classes wisely.

Knowing the tradeoffs and philosophy behind Swift’s preference helps you make better design decisions.

Under the Hood

Structs in Swift are stored as value types on the stack or inline in memory. When assigned or passed, Swift performs a copy of the entire data. This copy-on-assignment behavior means each struct instance owns its data independently. Swift’s compiler optimizes copying for performance, sometimes using copy-on-write to delay actual copying until mutation happens.

Why designed this way?

Swift was designed to be safe and fast. Using structs as value types avoids bugs from shared mutable state common in reference types. Copying data ensures isolation and predictability. The language balances this with performance optimizations like copy-on-write. Classes remain for cases needing inheritance and shared references, but structs are the default to encourage safer code.

┌───────────────┐
│ Struct Value  │
│ Stored on     │
│ Stack/Inline  │
└──────┬────────┘
       │ Copy on assignment
       ▼
┌───────────────┐     ┌───────────────┐
│ Copy 1        │     │ Copy 2        │
│ Independent   │     │ Independent   │
│ Data          │     │ Data          │
└───────────────┘     └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does modifying one struct copy change all other copies? Commit to yes or no.

Common Belief: Modifying one struct copy changes all copies because they share the same data.

Reality: Each struct copy is independent; changing one does not affect others.

Why it matters: Believing this leads to confusion and bugs when developers expect shared updates but see none.

Quick: Are structs always slower than classes because they copy data? Commit to yes or no.

Common Belief: Structs are slower than classes because copying data is expensive.

Reality: Structs are often faster for small data because they avoid reference counting and heap allocation overhead.

Why it matters: Misunderstanding this can cause developers to avoid structs unnecessarily, missing performance benefits.

Quick: Can structs in Swift inherit from other structs or classes? Commit to yes or no.

Common Belief: Structs support inheritance like classes do.

Reality: Structs do not support inheritance; only classes do.

Why it matters: Expecting inheritance in structs can lead to design mistakes and confusion about Swift’s type system.

Quick: Does using structs eliminate all bugs related to data sharing? Commit to yes or no.

Common Belief: Using structs means you never have to worry about shared data bugs.

Reality: Structs reduce shared data bugs but copying large structs can cause performance issues; also, reference types inside structs can still share data.

Why it matters: Overreliance on structs without understanding their limits can cause subtle bugs or inefficiencies.

Expert Zone

1

Swift uses copy-on-write optimization for many standard library structs like Array, delaying actual copying until mutation happens.

2

Structs can contain reference types as properties, which means internal data can still be shared even if the struct itself is a value type.

3

Choosing structs encourages immutable design patterns, which align well with Swift’s safety and concurrency goals.

When NOT to use

Avoid structs when you need inheritance, shared mutable state, or identity semantics. Use classes instead for reference semantics, or enums for fixed sets of cases. For very large data, consider classes or specialized data structures to avoid costly copying.

Production Patterns

In real apps, structs are used for models, configuration, and simple data containers. Classes are reserved for UI components, delegates, and shared resources. Developers combine structs with protocols and generics to build flexible, safe, and efficient codebases.

Connections

Immutable Data Structures

Structs promote immutability by copying data, similar to immutable data structures in functional programming.

Understanding structs helps grasp how immutability improves safety and predictability in software design.

Memory Management

Structs use stack allocation and copy semantics, contrasting with classes’ heap allocation and reference counting.

Knowing this connection clarifies performance and safety tradeoffs in Swift’s memory model.

Copy-on-Write Optimization

Swift structs often use copy-on-write to optimize copying, delaying it until mutation.

Recognizing this optimization explains how Swift balances safety with performance.

Common Pitfalls

#1 Modifying a struct expecting changes to reflect elsewhere.

Wrong approach:

var a = Point(x: 1, y: 2)
var b = a
b.x = 10
print(a.x) // Expecting 10 but gets 1

Correct approach:

var a = Point(x: 1, y: 2)
var b = a
b.x = 10
print(b.x) // 10
print(a.x) // 1

Root cause:

Misunderstanding that structs are copied on assignment, so changes to one copy don’t affect others.

#2 Using structs for large data without considering copy cost.

Wrong approach:

struct LargeData { var data: [Int] = Array(repeating: 0, count: 1000000) }
var a = LargeData()
var b = a // Copies large array immediately

Correct approach:

Use classes or optimize with copy-on-write types for large data to avoid expensive copies.

Root cause:

Not realizing that copying large structs can hurt performance.

#3 Trying to use inheritance with structs.

Wrong approach:

struct Animal {}
struct Dog: Animal {} // Error: structs cannot inherit

Correct approach:

Use protocols for shared behavior or classes for inheritance.

Root cause:

Confusing structs with classes and expecting inheritance support.

Key Takeaways

Structs in Swift are value types that create independent copies, making code safer and easier to understand.

They are preferred because they avoid bugs from shared mutable state and often improve performance by using stack storage.

Swift’s design encourages using structs for most data models, reserving classes for cases needing inheritance or shared identity.

Understanding copy behavior and mutability with structs helps prevent common programming mistakes.

Advanced optimizations like copy-on-write make structs efficient even when copying large data.