Swift Academy · Lezione

Come ARC conta i riferimenti

Cosa fa ARC in fase di compilazione, le chiamate retain/release e il ciclo di vita degli oggetti.

Come ARC conta i riferimenti è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Introduzione

L’Automatic Reference Counting (ARC) gestisce la memoria delle istanze delle classi. Comprendere come vengono contati i riferimenti aiuta a scrivere codice senza perdite di memoria.

Che cosa fa ARC

ARC tiene traccia del numero di riferimenti *strong* che puntano a ciascuna istanza di classe. Quando il conteggio raggiunge zero, chiama `deinit` e libera la memoria automaticamente.

Riferimenti strong

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

ARC avviene in fase di compilazione

ARC inserisce le chiamate retain/release in fase di compilazione, non durante l’esecuzione come farebbe un garbage collector. Questo comporta: • Nessuna pausa dovuta al GC • Deallocazione deterministica • Un lieve aumento delle dimensioni del codice dovuto alle chiamate retain/release

Rischio di cicli di riferimenti strong

```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! ```

Conteggio con più variabili

```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 nelle raccolte

```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 NON si applica ai tipi valore

Le struct, le enumerazioni e le tuple NON vengono conteggiate tramite riferimenti: ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

Osservare ARC con 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 ```

Prestazioni di ARC rispetto al GC

• GC: interrompe periodicamente l’esecuzione per raccogliere gli oggetti; compromesso tra throughput e latenza • ARC: dealloca immediatamente quando il conteggio raggiunge 0; non introduce pause • Overhead di ARC: ogni assegnazione tramite un riferimento strong comporta una coppia retain/release

Verifica rapida

Quando ARC chiama `deinit` e libera la memoria di un oggetto?

Riepilogo

Concetti chiave: • ARC tiene traccia dei riferimenti strong alle istanze delle classi • Conteggio 0 → viene chiamato `deinit` → la memoria viene liberata • ARC opera in fase di compilazione: nessuna pausa dovuta al GC • I tipi valore (struct/enum) non sono gestiti da ARC • I cicli impediscono al conteggio di raggiungere 0: usi weak/unowned Successivo: cicli di mantenimento.

Domande Frequenti

La lezione «Come ARC conta i riferimenti» è gratuita?

Sì — il testo completo di «Come ARC conta i riferimenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Come ARC conta i riferimenti»?

Cosa fa ARC in fase di compilazione, le chiamate retain/release e il ciclo di vita degli oggetti. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Come ARC conta i riferimenti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Come ARC conta i riferimenti
Cicli di retain: cause e rilevamento
Riferimenti weak e unowned
Liste di cattura delle closure e [weak self]

← Torna a Swift Academy