struct — ce este, concepte cheie și sintaxa în Swift

Ce este struct în Swift?

Struct (structură) — este un tip de date compus în Swift, care grupează proprietăți și metode asociate într-o entitate unică. Spre deosebire de clase, structurile sunt value types: la transmiterea către o funcție sau atribuirea unei noi variabile, se creează o copie independentă a structurii, nu o referință către obiectul original.

Swift folosește structuri pentru toate tipurile primitive: Int, Double, String, Bool, Array, Dictionary și Set. Aceasta înseamnă că chiar și numărul de bază Int se comportă ca o structură — la atribuire se creează o copie. Dezvoltatorul poate defini propria structură cu un set arbitrar de proprietăți și metode.

Conform Swift Evolution (SE-0143), decizia de a implementa tipurile standard ca structuri este motivată de performanță și predictibilitate. Value types nu creează cicluri de referință, nu necesită numărarea referințelor ARC și garantează că modificarea copiei nu va afecta originalul — acest lucru este critic pentru imutabilitatea datelor în scenarii multi-thread.

Struct ca value type

Value type semantics — diferența cheie între struct și class. Când atribui o structură unei noi variabile sau o transmiți unei funcții, Swift creează o copie independentă a tuturor datelor. Orice modificări ale copiei nu afectează originalul, eliminând efectele secundare caracteristice tipurilor referențiale.

// Exemplu de semantică value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 este o copie independentă a lui p1
p2.x = 99            // Doar p2 se modifică
print(p1.x)         // 10 — p1 neschimbat
print(p2.x)         // 99

Optimizarea Copy-on-Write

Swift utilizează Copy-on-Write (COW) pentru optimizarea copierii. Dacă mai multe variabile se referă la aceeași structură, dar niciuna nu modifică datele, copierea efectivă nu are loc. Swift partajează memoria între variabile până la prima mutație — atunci se creează o copie reală. Aceasta previne operațiile de alocare inutile și accelerează lucrul cu colecții.

Modificabilitate și metode mutating

Implicit, metodele structurii nu pot modifica proprietățile sale — Swift necesită indicarea explicită a mutating pentru metodele care introduc modificări. Această restricție protejează împotriva mutației accidentale și face codul predictibil: dacă o metodă nu este marcată mutating, aveți garanția că nu veți modifica structura.

Mutating în acțiune

Când adăugați cuvântul cheie mutating înaintea metodei, Swift obține capacitatea de a scrie valori noi în proprietățile structurii. De fapt, metoda poate chiar înlocui complet instanța structurii cu una nouă prin self = . Acest mecanism este utilizat, de exemplu, în tipurile Option și Result.

// Struct cu metodă mutating
struct Counter {
    private var value: Int = 0

    // Metoda mutating — poate modifica proprietăți
    mutating func increment() {
        value += 1
    }

    // Metoda mutating poate înlocui complet self
    mutating func reset() {
        self = Counter()
    }

    // Metoda non-mutating — doar citire
    func currentValue() -> Int {
        return value
    }
}

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

Reguli pentru mutating: structura trebuie declarată prin var, nu let — pentru o structură constantă nu se poate apela o metodă mutating. Compilatorul verifică acest lucru în faza de compilare: încercarea de a apela o metodă mutating pe o constantă let va duce la o eroare de compilare.

Struct vs Class: comparație

Alegerea între struct și class — una dintre deciziile fundamentale în Swift. Ambele tipuri pot conține proprietăți, metode, inițializatori și pot implementa protocoale, dar au diferențe fundamentale în semantica memoriei, moștenire și gestionarea ciclului de viață.

Structurile sunt preferate când datele nu necesită moștenire, nu trebuie să aibă identitate comună (de exemplu, coordonate, dimensiuni, configurație) și sunt transmise între module. Clasele sunt alese pentru componente UI (UIView, UIViewController), singleton și obiecte cu identitate comună.

Când să alegi struct

Apple recomandă utilizarea struct ca tip implicit pentru modelarea datelor în Swift. Structurile sunt potrivite pentru majoritatea scenariilor datorită semanticii previzibile de copiere și absenței costurilor suplimentare de numărare a referințelor. Să analizăm cazurile tipice când struct este alegerea optimă.

Modele de date fără moștenire

Dacă entitatea conține date fără necesitatea de moștenire (Product, User, Order, Point), utilizați struct. Compilatorul generează automat memberwise initializer — nu trebuie să scrieți init manual. Equatable și Hashable sunt, de asemenea, implementate automat pentru structurile ale căror proprietăți îndeplinesc aceste protocoale.

Date imutabile (immutable)

Pentru configurații, setări și flaguri care nu se modifică după creare, struct este preferabil class. O structură constantă (let) garantează imutabilitatea tuturor câmpurilor imbricate — în class aceasta se referă doar la referință, nu la conținutul obiectului.

Cod multi-thread

Structurile sunt sigure în medii multi-thread datorită value semantics. Fiecare fir primește o copie independentă a datelor și nu influențează alte fire. Condițiile de cursă între fire sunt imposibile pentru value types, ceea ce face struct alegerea preferată pentru modelele în SwiftUI (ObservableObject necesită class, dar @State folosește struct).

// Exemplu de utilizare struct pentru model de date
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

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

// Inițializator automat memberwise
let user = User(
    id: UUID(),
    name: "Alice",
    email: "alice@example.com",
    isPremium: true
)

// Copierea este sigură pentru multi-threading
var userCopy = user
userCopy.isPremium = false
// user.isPremium rămâne true

Utilizați class când aveți nevoie de moștenire (componente UIKit/AppKit), identitate comună (delegate, observer) sau ciclu de viață controlat al obiectelor (deinit). Pentru orice altceva — struct.