struct — définition, concepts clés et syntaxe en Swift

Qu'est-ce que struct en Swift ?

Struct (structure) est un type de données composite en Swift qui regroupe des propriétés et des méthodes connexes en une seule entité. Contrairement aux classes, les structures sont des value types : lorsqu'elles sont passées à une fonction ou affectées à une nouvelle variable, une copie indépendante de la structure est créée, et non une référence à l'objet d'origine.

Swift utilise des structures pour tous les types primitifs : Int, Double, String, Bool, Array, Dictionary et Set. Cela signifie que même un Int de base se comporte comme une structure — une copie est créée lors de l'affectation. Le développeur peut définir sa propre structure avec n'importe quel ensemble de propriétés et de méthodes.

Selon Swift Evolution (SE-0143), la décision d'implémenter les types standard comme des structures est motivée par la performance et la prévisibilité. Les value types ne créent pas de cycles de référence, ne nécessitent pas de comptage de références ARC et garantissent que la modification d'une copie n'affecte pas l'original — ceci est d'une importance cruciale pour l'immuabilité des données dans les scénarios multithread.

Struct en tant que value type

La sémantique des value types est la différence clé entre struct et class. Lorsque vous assignez une structure à une nouvelle variable ou la passez à une fonction, Swift crée une copie indépendante de toutes les données. Toute modification de la copie n'affecte pas l'original, éliminant les effets secondaires typiques des types de référence.

// Exemple de sémantique de value type
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 10, y: 20)
var p2 = p1        // p2 est une copie indépendante de p1
p2.x = 99            // Seul p2 change
print(p1.x)         // 10 — p1 inchangé
print(p2.x)         // 99

Optimisation Copy-on-Write

Swift utilise Copy-on-Write (COW) pour optimiser la copie. Si plusieurs variables référencent la même structure mais qu'aucune ne modifie les données, aucune copie réelle n'a lieu. Swift partage la mémoire entre les variables jusqu'à la première mutation — alors une copie réelle est créée. Cela évite les opérations d'allocation excessives et accélère le travail avec les collections.

Mutabilité et méthodes mutating

Par défaut, les méthodes d'une structure ne peuvent pas modifier ses propriétés — Swift exige le mot-clé explicite mutating pour les méthodes qui effectuent des modifications. Cette restriction protège contre les mutations accidentelles et rend le code prévisible : si une méthode n'est pas marquée mutating, vous avez la garantie de ne pas modifier la structure.

Mutating en action

Lorsque vous ajoutez le mot-clé mutating avant une méthode, Swift acquiert la capacité d'écrire de nouvelles valeurs dans les propriétés de la structure. En fait, la méthode peut même remplacer complètement l'instance de la structure par une nouvelle via self =. Ce mécanisme est utilisé, par exemple, dans les types Option et Result.

// Struct avec méthode mutating
struct Counter {
    private var value: Int = 0

    // Méthode mutating — peut modifier les propriétés
    mutating func increment() {
        value += 1
    }

    // La méthode mutating peut remplacer entièrement self
    mutating func reset() {
        self = Counter()
    }

    // Méthode non mutating — lecture seule
    func currentValue() -> Int {
        return value
    }
}

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

Règles pour mutating : la structure doit être déclarée avec var, pas avec let — une structure constante ne peut pas appeler une méthode mutating. Le compilateur vérifie cela à la compilation : tenter d'appeler une méthode mutating sur une constante let entraînera une erreur de compilation.

Struct vs Class : comparaison

Le choix entre struct et class est l'une des décisions fondamentales en Swift. Les deux types peuvent contenir des propriétés, des méthodes, des initialiseurs et implémenter des protocoles, mais ils présentent des différences fondamentales dans la sémantique mémoire, l'héritage et la gestion du cycle de vie.

Les structures sont préférables lorsque les données ne nécessitent pas d'héritage, ne doivent pas avoir d'identité partagée (par exemple, coordonnées, tailles, configuration) et sont transmises entre les modules. Les classes sont choisies pour les composants d'interface utilisateur (UIView, UIViewController), les singletons et les objets avec une identité partagée.

Quand choisir struct

Apple recommande d'utiliser struct comme type par défaut pour la modélisation des données en Swift. Les structures conviennent à la plupart des scénarios grâce à une sémantique de copie prévisible et à l'absence de surcharge de comptage de références. Examinons les cas typiques où struct est le choix optimal.

Modèles de données sans héritage

Si une entité contient des données sans nécessité d'héritage (Product, User, Order, Point), utilisez struct. Le compilateur génère automatiquement un initialiseur memberwise — vous n'avez pas besoin d'écrire manuellement init. Equatable et Hashable sont également implémentés automatiquement pour les structures dont toutes les propriétés sont conformes à ces protocoles.

Données immuables

Pour les configurations, paramètres et indicateurs qui ne changent pas après la création, struct est préférable à class. Une structure constante (let) garantit l'immuabilité de tous les champs imbriqués — dans une class, cela ne s'applique qu'à la référence, pas au contenu de l'objet.

Code multithread

Les structures sont sûres dans les environnements multithread grâce à la sémantique de valeur. Chaque thread obtient une copie indépendante des données et n'affecte pas les autres threads. Les conditions de course entre les threads sont impossibles pour les value types, faisant de struct le choix privilégié pour les modèles dans SwiftUI (ObservableObject nécessite class, mais @State utilise struct).

// Exemple d'utilisation de struct pour modèle de données
struct User: Codable, Identifiable {
    let id: UUID
    var name: String
    var email: String
    var isPremium: Bool

    // Propriété calculée — non mutating
    var displayName: String {
        isPremium ? "\(name) ⭐️" : name
    }
}

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

// La copie est sûre pour le multithreading
var userCopy = user
userCopy.isPremium = false
// user.isPremium reste true

Utilisez class lorsque vous avez besoin d'héritage (composants UIKit/AppKit), d'identité partagée (delegate, observer) ou d'un cycle de vie d'objet contrôlé (deinit). Pour tout le reste — utilisez struct.