Swift Academy · Leçon

Comment ARC compte les références

Comprendre ce que fait ARC à la compilation, les appels retain/release et la durée de vie des objets.

Comment ARC compte les références est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

Le comptage automatique des références (ARC) gère la mémoire des instances de classes. Comprendre comment il compte les références vous aide à écrire du code sans fuites.

Ce que fait ARC

ARC suit le nombre de références *fortes* qui pointent vers chaque instance de classe. Lorsque le compteur atteint zéro, il appelle `deinit` et libère la mémoire — automatiquement.

Références fortes

```swift var a: Dog? = Dog(name: "Rex") // count = 1 var b = a // count = 2 a = nil // count = 1 b = nil // count = 0 → deinit ```

ARC agit à la compilation

ARC insère les appels à retain et release lors de la compilation — et non à l’exécution comme un ramasse-miettes. Cela signifie : • Aucune pause due au ramasse-miettes • Désallocation déterministe • Légère surcharge de la taille du code due aux appels à retain et release

Risque de cycle de références fortes

```swift class Node { var next: Node? } var n1: Node? = Node() var n2: Node? = Node() n1?.next = n2 n2?.next = n1 // cycle! n1 = nil; n2 = nil // both stuck at count=1 — leaked! ```

Compter avec plusieurs variables

```swift class Engine {} var car1: Engine? = Engine() // count = 1 var car2 = car1 // count = 2 var car3 = car2 // count = 3 car1 = nil // count = 2 car2 = nil // count = 1 // Engine still alive — car3 holds it car3 = nil // count = 0 → deinit ```

ARC dans les collections

```swift var dogs: [Dog] = [] dogs.append(Dog(name:"A")) // count = 1 dogs.append(Dog(name:"B")) // count = 1 each dogs.removeAll() // both deinit called ```

ARC NE S’APPLIQUE PAS aux types valeur

Les structures, les énumérations et les tuples ne sont PAS comptés par références : ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

Observer ARC avec `deinit`

```swift class Cat { let name: String init(name: String) { self.name = name; print("\(name) born") } deinit { print("\(name) deallocated") } } var c: Cat? = Cat(name: "Luna") c = nil // "Luna deallocated" printed ```

Performances d’ARC et du ramasse-miettes

• GC : suspend périodiquement l’exécution pour effectuer la collecte ; compromis entre débit et latence • ARC : désalloue immédiatement lorsque le compteur atteint 0 ; aucune pause • Surcharge d’ARC : chaque affectation via une référence forte coûte une paire retain/release

Vérification rapide

Quand ARC appelle-t-il `deinit` et libère-t-il la mémoire d’un objet ?

Récapitulatif

Points essentiels : • ARC suit les références fortes vers les instances de classes • Compteur à 0 → `deinit` est appelé → mémoire libérée • ARC agit à la compilation — aucune pause due au ramasse-miettes • Les types valeur (structures et énumérations) ne sont pas gérés par ARC • Les cycles empêchent le compteur d’atteindre 0 → utilisez des références `weak`/`unowned` Ensuite : les cycles de rétention.

Questions Fréquemment Posées

La leçon « Comment ARC compte les références » est-elle gratuite ?

Oui — le texte complet de « Comment ARC compte les références » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comment ARC compte les références » ?

Comprendre ce que fait ARC à la compilation, les appels retain/release et la durée de vie des objets. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Comment ARC compte les références » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Comment ARC compte les références
Cycles de rétention : causes et détection
Références weak et unowned
Listes de capture des fermetures et [weak self]

← Retour à Swift Academy