struct — wat is het, kernconcepten en syntaxis in Swift

Wat is struct in Swift?

Struct (structuur) — is een samengesteld gegevenstype in Swift dat gerelateerde eigenschappen en methoden groepeert in één entiteit. In tegenstelling tot klassen zijn structuren value types: bij overdracht aan een functie of toewijzing aan een nieuwe variabele wordt een onafhankelijke kopie van de structuur gemaakt, geen verwijzing naar het originele object.

Swift gebruikt structuren voor alle primitieve typen: Int, Double, String, Bool, Array, Dictionary en Set. Dit betekent dat zelfs een basisgetal Int zich als een structuur gedraagt — bij toewijzing wordt een kopie gemaakt. De ontwikkelaar kan zijn eigen structuur definiëren met een willekeurige set eigenschappen en methoden.

Volgens Swift Evolution (SE-0143) is de beslissing om standaardtypen als structuren te implementeren ingegeven door prestaties en voorspelbaarheid. Value types creëren geen referentiecycli, vereisen geen ARC-referentietelling en garanderen dat wijziging van de kopie het origineel niet beïnvloedt — dit is cruciaal voor onveranderlijkheid van gegevens in multithreaded scenario's.

Struct als value type

Value type semantics — het belangrijkste verschil tussen struct en class. Wanneer u een structuur aan een nieuwe variabele toewijst of aan een functie doorgeeft, maakt Swift een onafhankelijke kopie van alle gegevens. Eventuele wijzigingen in de kopie hebben geen invloed op het origineel, waardoor bijwerkingen die kenmerkend zijn voor referentietypen worden geëlimineerd.

// Voorbeeld van value type semantiek
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 is een onafhankelijke kopie van p1
p2.x = 99            // Alleen p2 verandert
print(p1.x)         // 10 — p1 ongewijzigd
print(p2.x)         // 99

Copy-on-Write optimalisatie

Swift gebruikt Copy-on-Write (COW) om kopiëren te optimaliseren. Als meerdere variabelen naar dezelfde structuur verwijzen, maar geen van hen de gegevens wijzigt, vindt er geen daadwerkelijk kopiëren plaats. Swift deelt het geheugen tussen variabelen tot de eerste mutatie — dan wordt een echte kopie gemaakt. Dit voorkomt overbodige allocatie-operaties en versnelt het werken met collecties.

Veranderlijkheid en mutating methoden

Standaard kunnen methoden van een structuur de eigenschappen ervan niet wijzigen — Swift vereist expliciete vermelding van mutating voor methoden die wijzigingen aanbrengen. Deze beperking beschermt tegen accidentele mutatie en maakt de code voorspelbaar: als een methode niet is gemarkeerd als mutating, heeft u de garantie dat u de structuur niet zult wijzigen.

Mutating in actie

Wanneer u het trefwoord mutating voor de methode plaatst, krijgt Swift de mogelijkheid om nieuwe waarden in de eigenschappen van de structuur te schrijven. In feite kan de methode de instantie van de structuur zelfs volledig vervangen door een nieuwe via self = . Dit mechanisme wordt bijvoorbeeld gebruikt in de typen Option en Result.

// Struct met mutating methode
struct Counter {
    private var value: Int = 0

    // Mutating methode — kan eigenschappen wijzigen
    mutating func increment() {
        value += 1
    }

    // Mutating methode kan self volledig vervangen
    mutating func reset() {
        self = Counter()
    }

    // Non-mutating methode — alleen lezen
    func currentValue() -> Int {
        return value
    }
}

var counter = Counter()
counter.increment()
print(counter.currentValue())  // 1
counter.reset()
print(counter.currentValue())  // 0

Regels voor mutating: de structuur moet worden gedeclareerd met var, niet met let — voor een constante structuur kan een mutating methode niet worden aangeroepen. De compiler controleert dit tijdens het compileren: een poging om een mutating methode aan te roepen op een let-constante leidt tot een compilatiefout.

Struct vs Class: vergelijking

De keuze tussen struct en class — een van de fundamentele beslissingen in Swift. Beide typen kunnen eigenschappen, methoden, initializers bevatten en protocollen implementeren, maar hebben fundamentele verschillen in geheugensemantiek, overerving en levenscyclusbeheer.

Structuren hebben de voorkeur wanneer gegevens geen overerving vereisen, geen gedeelde identiteit mogen hebben (bijvoorbeeld coördinaten, afmetingen, configuratie) en tussen modules worden doorgegeven. Klassen worden gekozen voor UI-componenten (UIView, UIViewController), singleton en objecten met gedeelde identiteit.

Wanneer struct kiezen

Apple raadt aan om struct te gebruiken als standaardtype voor het modelleren van gegevens in Swift. Structuren zijn geschikt voor de meeste scenario's dankzij de voorspelbare kopieersemantiek en de afwezigheid van overhead voor referentietelling. Laten we de typische gevallen bekijken waarin struct de optimale keuze is.

Gegevensmodellen zonder overerving

Als de entiteit gegevens bevat zonder noodzaak tot overerving (Product, User, Order, Point), gebruik dan struct. De compiler genereert automatisch een memberwise initializer — u hoeft init niet handmatig te schrijven. Equatable en Hashable worden ook automatisch geïmplementeerd voor structuren waarvan alle eigenschappen aan deze protocollen voldoen.

Onveranderlijke (immutable) gegevens

Voor configuraties, instellingen en vlaggen die niet veranderen na creatie, heeft struct de voorkeur boven class. Een constante (let) structuur garandeert de onveranderlijkheid van alle geneste velden — bij class heeft dit alleen betrekking op de verwijzing, niet op de inhoud van het object.

Multithreaded code

Structuren zijn veilig in een multithreaded omgeving vanwege value semantics. Elke thread krijgt een onafhankelijke kopie van de gegevens en beïnvloedt andere threads niet. Race conditions tussen threads zijn onmogelijk voor value types, wat struct de voorkeurskeuze maakt voor modellen in SwiftUI (ObservableObject vereist class, maar @State gebruikt struct).

// Voorbeeld van struct gebruik voor gegevensmodel
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Computed eigenschap — non-mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

// Automatische memberwise initializer
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Kopiëren is veilig voor multithreading
var userCopy = user
userCopy.isPremium = false
// user.isPremium blijft true

Gebruik class wanneer u overerving (UIKit/AppKit componenten), gedeelde identiteit (delegate, observer) of gecontroleerde levensduur van objecten (deinit) nodig hebt. Voor al het andere — struct.