Structs & Value Types

Reviewed & published by Brayan K

Structs are the backbone of Swift data modelling — Apple recommends them by default. By the end of this lesson you'll define structs, understand value semantics (copy-on-assign), use the free memberwise initializer, and write mutating methods.

Part of the free Swift course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• • Define data models with struct
• • Understand value semantics: structs are copied on assignment
• • Use the free memberwise initializer
• • Write mutating methods that change stored properties
• • Know why a let struct is fully immutable

1️⃣ Defining a Struct

Declare a struct and list its stored properties. Swift hands you a free memberwise initializer — one argument per property — so you rarely write init yourself.

// A STRUCT bundles related data (and behaviour) into a named type.
struct Point {
    var x: Int
    var y: Int
}

// Structs get a FREE memberwise initializer — no init() to write.
let origin = Point(x: 0, y: 0)
let p = Point(x: 3, y: 4)
print("p is (\(p.x), \(p.y))")     // p is (3, 4)

// Structs can hold different types and have defaults.
struct User {
    var name: String
    var age: Int = 0                 // default value
}
let u = User(name: "Ada")            // age defaults to 0
print("\(u.name), \(u.age)")        // Ada, 0

2️⃣ Value Semantics (Copy on Assign)

This is the defining trait of structs: assigning one to a new variable, or passing it to a function, makes an independent copy. Changing the copy never touches the original — no hidden sharing, no surprises.

// VALUE SEMANTICS: assigning a struct makes an independent COPY.
struct Point { var x: Int; var y: Int }

var a = Point(x: 1, y: 2)
var b = a                 // b is a COPY of a
b.x = 99                  // change only b

print("a.x = \(a.x)")     // a.x = 1   (unchanged!)
print("b.x = \(b.x)")     // b.x = 99

// Passing a struct to a function also copies it — the original is safe.
func moveRight(_ point: Point) -> Point {
    var copy = point
    copy.x += 10
    return copy
}
let moved = moveRight(a)
print("a.x = \(a.x), moved.x = \(moved.x)")   // a.x = 1, moved.x = 11

3️⃣ Mutating Methods

A method that changes the struct's own properties must be marked mutating. You can only call mutating methods on a var instance — a let struct is fully immutable.

// A method that changes the struct's own properties must be 'mutating'.
struct Counter {
    var count = 0

    mutating func increment() {       // changes self -> needs 'mutating'
        count += 1
    }

    func describe() -> String {       // only reads -> no 'mutating'
        return "count is \(count)"
    }
}

var c = Counter()
c.increment()
c.increment()
print(c.describe())                   // count is 2

// ⚠️ A 'let' struct is immutable — you can't call mutating methods on it.
// let fixed = Counter()
// fixed.increment()                  // ❌ compile error

Your turn. Fill in the blanks, then run it and check the output.

// 🎯 YOUR TURN — replace each ___ then run it in SwiftFiddle.

// 1) Define a struct 'Rectangle' with width and height (both Double).
___ Rectangle {                       // 👉 replace ___ with the keyword struct
    var width: Double
    var height: Double

    // 2) Add a method 'area' that returns width * height.
    func area() -> Double {
        return ___                     // 👉 replace ___ with width * height
    }
}

// 3) Make one using the free memberwise initializer.
let r = Rectangle(width: 3, height: 4)
print("Area: \(r.area())")

// ✅ Expected output:
//    Area: 12.0

Pro Tips

• 💡 Prefer structs by default. Reach for a class only when you truly need shared, reference behaviour or inheritance.
• 💡 Let Swift write the initializer. The memberwise init saves boilerplate; add defaults for optional fields.
• 💡 Value semantics prevent bugs. No two parts of your program can secretly mutate the same struct.
• 💡 Add computed properties (see Properties) for derived values like area without storing them.

Common Errors (and the fix)

• "Cannot assign to property: 'self' is immutable" — a method changes a property but isn't marked mutating. Add the keyword.
• "Cannot use mutating member on immutable value" — you called a mutating method on a let. Declare the instance as var.
• Expecting shared state — structs copy. If you change a copy and the "original" didn't update, that's value semantics working as intended (use a class if you truly need sharing).
• "Missing argument for parameter" — the memberwise init needs every non-defaulted property. Provide it or give the property a default.

📋 Quick Reference

Mini-Challenge: Bank Account

Build it, run it, and check your output against the example in the comments — especially the part proving copies are independent.

// 🎯 MINI-CHALLENGE: Bank account
// 1. Define a struct 'Account' with a stored property 'balance' (Double, default 0).
// 2. Add a mutating method deposit(_ amount: Double) that adds to balance.
// 3. Add a mutating method withdraw(_ amount: Double) that subtracts.
// 4. Make a var account, deposit 100, withdraw 30, and print the balance.
// 5. Copy it: let snapshot = account. Deposit another 50 into account,
//    then print BOTH account.balance and snapshot.balance to prove copies
//    are independent (snapshot should NOT change).
//
// ✅ Example output:
//    Balance: 70.0
//    account: 120.0  snapshot: 70.0

// your code here

🎉 Lesson Complete!

• ✅ struct defines a value type — copied on assignment
• ✅ Swift provides a free memberwise initializer
• ✅ Methods that change properties need mutating
• ✅ A let struct is fully immutable; structs don't inherit

Practice quiz

Continue this course

• Previous: Enumerations & Associated Values
• Next: Classes & Reference Types — Reference semantics, init/deinit, inheritance — and struct vs class

Frequently asked questions

What does it mean that structs are value types?

It means a struct is copied whenever you assign it to a new variable, pass it to a function, or return it. The copy is independent: changing one does not affect the other. This makes structs predictable and safe — there's no hidden sharing, so you never accidentally mutate data that another part of your program relies on.

What is the memberwise initializer?

For every struct, Swift automatically generates an initializer that takes one argument per stored property, in declaration order: a struct with x and y gets Point(x:y:). You don't write it yourself. If you provide your own init, the memberwise one is replaced — though you can keep both by defining your custom init in an extension.

Why do some methods need the 'mutating' keyword?

Because struct instances are value types, their methods are not allowed to change the instance's stored properties unless explicitly marked mutating. The keyword documents that calling the method alters the value, and it also means you can only call it on a var instance — a let struct is fully immutable.

When should I choose a struct over a class?

Apple recommends preferring structs by default. Choose a struct for data models, values that are compared by their contents, and anything you want copied rather than shared — coordinates, money, settings, model objects. Reach for a class only when you specifically need reference semantics (shared mutable state), inheritance, or identity.

Can structs have methods and conform to protocols?

Yes. Structs can have stored and computed properties, instance and static methods, initializers, and they can conform to protocols like Equatable, Codable, and Comparable. What they cannot do is inherit from another struct — inheritance is exclusive to classes. For shared behaviour, structs use protocols and protocol extensions instead.

Related lessons

• functions
• Properties