Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Swift

Partie 3 sur 5

Niveau de lecture :

6Types valeur et types référence

6.1struct et class

Swift distingue deux grandes familles de types. Les structures (struct) sont des types valeur : affecter une structure à une autre variable en fait une copie indépendante. Les classes (class) sont des types référence : deux variables peuvent désigner le même objet, et une modification par l’une se voit par l’autre (voir la programmation orientée objet). Les classes seules permettent l’héritage.

struct Point { var x: Double; var y: Double }

var a = Point(x: 1, y: 2)
var b = a          // copie
b.x = 10
print(a.x)         // 1 : a n'a pas changé

Swift encourage à utiliser les structures par défaut : sans partage caché, le code est plus facile à comprendre et plus sûr en présence de traitements simultanés. Les types de base, String, Array ou Dictionary, sont eux-mêmes des structures. Pour éviter des copies coûteuses, ils utilisent la copie à l’écriture : la copie réelle n’a lieu qu’au moment où l’une des deux versions est modifiée.

6.2Les énumérations

Les énumérations de Swift peuvent porter des valeurs associées, différentes pour chaque cas, comme celles de Rust. Combinées au switch exhaustif, elles décrivent proprement des situations variées :

enum Paiement {
    case carte(numeroMasque: String)
    case virement(iban: String)
    case especes
}

func description(_ p: Paiement) -> String {
    switch p {
    case .carte(let n):    return "Carte \(n)"
    case .virement:        return "Virement"
    case .especes:         return "Espèces"
    }
}

6.3Protocoles et extensions

Un protocole décrit un ensemble de méthodes et de propriétés, comme une interface en Java. Structures, classes et énumérations peuvent l’adopter. Les extensions ajoutent des fonctions à un type existant, et peuvent fournir une implémentation par défaut aux méthodes d’un protocole. Apple a présenté en 2015 cette façon de concevoir comme une « programmation orientée protocoles », qui privilégie la composition de petits protocoles plutôt que de longues hiérarchies de classes. La généricité permet d’écrire des fonctions et des types qui fonctionnent avec tout type respectant un protocole, comme Comparable ou Codable, ce dernier permettant de convertir automatiquement un type en JSON et inversement (voir XML et JSON).

6.4Un exemple : lire du JSON

Il suffit de déclarer qu’une structure adopte le protocole Codable pour que Swift sache la lire et l’écrire en JSON, en associant chaque propriété à la clé de même nom. Si une donnée manque ou n’a pas le bon type, le décodage lève une erreur, au lieu de produire un objet incomplet :

struct Meteo: Codable {
    let ville: String
    let temperature: Double
    let alerte: String?          // facultatif dans le JSON
}

let json = #"{"ville": "Lyon", "temperature": 18.5}"#.data(using: .utf8)!
do {
    let m = try JSONDecoder().decode(Meteo.self, from: json)
    print("\(m.ville) : \(m.temperature) °C")
} catch {
    print("Données invalides : \(error)")
}

Cette vérification à l’exécution est précieuse pour la sécurité : contrairement à TypeScript, dont les types disparaissent à l’exécution, Swift contrôle réellement la forme des données reçues avant de les ranger dans un type (voir TypeScript). Elle ne vérifie pas pour autant les valeurs elles-mêmes, comme une température aberrante, qui restent à contrôler par le programme.

Pour s’exercer

Exercice 3 : structure ou classe ?

Qu’affichent ces deux programmes ?

struct CompteS { var solde = 100 }
class CompteC { var solde = 100 }

var s1 = CompteS(); var s2 = s1; s2.solde = 0
let c1 = CompteC(); let c2 = c1; c2.solde = 0
print(s1.solde, c1.solde)
Voir la réponse

Le programme affiche 100 0. s2 est une copie indépendante de s1, puisqu’une structure est un type valeur : modifier s2 ne change pas s1. c2 et c1 désignent le même objet, puisqu’une classe est un type référence : vider le solde par c2 le vide aussi pour c1. On remarque aussi qu’on peut modifier c2.solde alors que c2 est déclaré avec let : la constante est la référence, pas l’objet désigné.

Exercice 4 : un cas de plus

On ajoute à l’énumération Paiement de la section 6.2 un cas case cheque(numero: Int). Que se passe-t-il pour la fonction description ? Comment la corriger ?

Voir la réponse

Le compilateur la refuse : le switch n’est plus exhaustif, le cas .cheque n’est pas traité. On ajoute case .cheque(let numero): return "Chèque n° \(numero)". Il ne faut pas ajouter un default qui couvrirait tous les cas restants : il ferait taire le compilateur, qui ne signalerait plus les oublis lors des prochains ajouts.

Exercice 5 : guard plutôt qu’imbriquer

Réécrivez cette fonction avec guard pour éviter l’imbrication :

func envoyer(courriel: String?, message: String?) {
    if let courriel {
        if let message {
            if !message.isEmpty {
                transmettre(message, a: courriel)
            }
        }
    }
}
Voir la réponse

func envoyer(courriel: String?, message: String?) {
    guard let courriel, let message, !message.isEmpty else {
        print("Envoi impossible : informations manquantes")
        return
    }
    transmettre(message, a: courriel)
}

Les conditions de validité sont regroupées en tête de fonction, le cas d’erreur est traité immédiatement, et le traitement principal n’est plus enfoui sous trois niveaux d’indentation. C’est le style recommandé en Swift.

7La gestion de la mémoire

Swift ne demande pas au programmeur de libérer la mémoire, mais n’utilise pas non plus de ramasse-miettes. Il applique le comptage automatique de références (en anglais Automatic Reference Counting, ARC) : chaque objet d’une classe tient le compte du nombre de variables qui le désignent ; le compilateur insère les opérations d’incrémentation et de décrémentation, et l’objet est libéré dès que ce compte tombe à zéro. La libération est immédiate et prévisible, sans les pauses d’un ramasse-miettes, ce qui convient aux appareils mobiles (voir la gestion de la mémoire).

Le comptage de références a un point faible : les cycles. Si un objet A désigne B et que B désigne A, leurs compteurs ne tombent jamais à zéro, même quand plus rien d’autre ne les utilise : la mémoire fuit. On rompt ces cycles en déclarant l’une des deux références weak (« faible »), qui ne compte pas et devient automatiquement nil quand l’objet disparaît, ou unowned, pour une référence dont on sait qu’elle survivra toujours à l’objet (exercice 6).

class Employe {
    let nom: String
    weak var service: Service?      // ne retient pas le service
    init(nom: String) { self.nom = nom }
}

class Service {
    var employes: [Employe] = []    // retient ses employés
}

Pour la sécurité, ce modèle offre une garantie importante : dans le code Swift ordinaire, on ne peut pas utiliser un objet déjà libéré. Swift propose aussi des pointeurs bruts, dans des types dont le nom commence par Unsafe, pour dialoguer avec le C ; comme le code unsafe de Rust, ils signalent les zones à relire avec soin.

Pour s’exercer

Exercice 6 : la fuite de mémoire

Dans l’exemple de la section 7, que se passerait-il si la propriété service de Employe n’était pas déclarée weak ?

Voir la réponse

Le service retiendrait ses employés, et chaque employé retiendrait son service : un cycle de références. Quand le reste du programme n’utilise plus ni le service ni ses employés, leurs compteurs ne tombent pas à zéro, puisqu’ils se désignent mutuellement, et ils ne sont jamais libérés : c’est une fuite de mémoire. Avec weak, la référence de l’employé vers le service ne compte pas ; quand plus rien d’autre ne désigne le service, il est libéré, puis ses employés avec lui. L’outil Instruments de Xcode aide à repérer ces cycles. Les fermetures qui utilisent self créent souvent ce genre de cycle ; on écrit alors [weak self] au début de la fermeture.