Parlez du cycle de vie d'un objet dans iOS.

Le cycle de vie d’un objet dans iOS est géré par le mécanisme de comptage de références (Reference Counting). La méthode la plus courante est le Comptage Automatique des Références (ARC).

Étapes du cycle de vie :

Création (Creation) : L’objet est créé par l’initialisation de la classe. Le compteur de références est réglé à 1.
```
// Initialisation d’un objet de la classe MyClass
let myObject = MyClass() 
```
Utilisation (Usage) : L’objet est utilisé dans l’application. D’autres objets peuvent obtenir des références à celui-ci, augmentant le compteur de références.
```
// Un autre objet obtient une référence
anotherObject.referenceToMyObject = myObject 
// Le compteur de références de myObject augmente
```
Désallocation (Deallocation) : Lorsque le compteur de références de l’objet atteint zéro, le runtime appelle automatiquement la méthode deinit() (pour les classes Objective-C - dealloc). L’objet libère la mémoire occupée.
```
deinit {
    // Code pour libérer les ressources
    print("Objet détruit")
}
```

Problèmes et solutions :

Cycles de rétention (Retain Cycles) : Se produisent lorsque deux ou plusieurs objets ont des références fortes entre eux. Le compteur de références de chaque objet n’atteint jamais zéro, et les objets ne seront pas désasignés.
Solutions :
- Références faibles (Weak References) : Indiquées par le mot-clé weak. N’augmentent pas le compteur de références. Utilisées pour les références aux objets parents ou délégués, lorsque la relation est temporaire ou optionnelle.
- Références non possédées (Unowned References) : Indiquées par le mot-clé unowned. N’augmentent pas le compteur de références. Utilisées lorsque les objets liés ont toujours un cycle de vie identique, et que la référence ne sera pas nil au moment de l’utilisation. Si l’objet référencé par une référence non possédée est désasigné, une tentative d’accès à cette référence entraînera une erreur d’exécution.

Exemple de weak et unowned dans des closures pour éviter les cycles de références fortes :

class Person {
    let name: String
    // Référence faible à la closure pour éviter le cycle
    var greeting: (() -> Void)? 

    init(name: String) {
        self.name = name
        // Capture self comme référence weak
        greeting = { [weak self] in 
            guard let self = self else { return }
            print("Bonjour, \(self.name)!")
        }
    }

    deinit {
        print("\(name) est en train d’être désasigné")
    }
}

class Apartment {
    let unit: String
    // Référence faible au locataire
    weak var tenant: Person? 

    init(unit: String) {
        self.unit = unit
    }

    deinit {
        print("Appartement \(unit) est en train d’être désasigné")
    }
}

Une gestion correcte des références est essentielle pour éviter les fuites de mémoire et maintenir la stabilité de l’application.