Swift Academy · Lezione

Deinizializzatori e ciclo di vita della memoria

Utilizzare deinit per liberare le risorse prima che un oggetto venga deallocato.

Deinizializzatori e ciclo di vita della memoria è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Benvenuto

Le classi Swift possono definire un `deinit` che viene eseguito subito prima che l'istanza venga deallocata. Comprendere l'intero ciclo di vita dell'oggetto — init → use → deinit — è fondamentale per la gestione delle risorse.

Che cos'è deinit?

```swift class FileHandle { let path: String init(path: String) { self.path = path; print("Opened \(path)") } deinit { print("Closed \(path)") } } do { let f = FileHandle(path: "/tmp/log.txt") } // deinit called here when f goes out of scope ```

Regole sintattiche di deinit

• Solo le classi: struct ed enum non hanno `deinit` • Nessun parametro né valore restituito • Nessuna parentesi: `deinit { }`, non `deinit() { }` • Chiamato automaticamente da ARC: non lo chiami mai personalmente • Il `deinit` della superclasse viene chiamato automaticamente dopo il `deinit` della sottoclasse

Casi d'uso per la pulizia

Usi comuni di `deinit`: • Chiudere le connessioni di rete • Rimuovere gli observer delle notifiche: `NotificationCenter.default.removeObserver(self)` • Invalidare i timer • Chiudere i file handle o le connessioni al database

Conteggio dei retain e ciclo di vita

ARC tiene traccia del numero di riferimenti forti che puntano a un oggetto: ```swift var a: Dog? = Dog() // retain count = 1 var b = a // retain count = 2 a = nil // retain count = 1 b = nil // retain count = 0 → deinit called ```

Catena di deinit delle sottoclassi

```swift class Base { deinit { print("Base deinit") } } class Child: Base { deinit { print("Child deinit") } // super.deinit called automatically after } var c: Child? = Child() c = nil // prints: Child deinit, then Base deinit ```

weak impedisce il retain

```swift class Owner { var pet: Dog? deinit { print("Owner gone") } } class Dog { weak var owner: Owner? // weak = no strong retain deinit { print("Dog gone") } } ``` Quando `owner` viene impostato su nil, `Owner` può essere deallocato anche se `Dog` mantiene un riferimento.

I cicli di retain impediscono deinit

```swift class A { var b: B? } class B { var a: A? } var a: A? = A() var b: B? = B() a?.b = b b?.a = a a = nil b = nil // deinit never called — retain cycle! ```

Pattern per invalidare un timer

```swift class PollingService { var timer: Timer? func start() { timer = Timer.scheduledTimer(...) } deinit { timer?.invalidate() timer = nil print("Timer stopped") } } ```

Rilevamento delle perdite con Instruments

Se `deinit` non viene mai chiamato, probabilmente è presente un ciclo di retain. Utilizzi il template Leaks di Xcode Instruments per rilevare gli oggetti allocati ma mai deallocati.

Verifica rapida

Quali tipi possono definire un `deinit`?

Riepilogo

Concetti chiave: • `deinit { }` — pulisce le risorse prima della deallocazione • Solo le classi; il `deinit` della superclasse viene chiamato automaticamente dopo quello della sottoclasse • ARC determina quando viene eseguito `deinit` (quando il conteggio dei retain scende a 0) • I cicli di retain impediscono `deinit`: li interrompa con `weak`/`unowned` • Utilizzi Instruments Leaks per trovare gli oggetti il cui `deinit` non viene mai eseguito Corso completato! Prossimo argomento: pattern degli enum e macchine a stati.

Domande Frequenti

La lezione «Deinizializzatori e ciclo di vita della memoria» è gratuita?

Sì — il testo completo di «Deinizializzatori e ciclo di vita della memoria» è 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 «Deinizializzatori e ciclo di vita della memoria»?

Utilizzare deinit per liberare le risorse prima che un oggetto venga deallocato. 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 4 di 4.

Quanto tempo richiede la lezione «Deinizializzatori e ciclo di vita della memoria»?

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

Ereditarietà delle classi e parola chiave super
override, final e prevenzione delle sottoclassi
Conversione dei tipi: is, as?, as! e as
Deinizializzatori e ciclo di vita della memoria

← Torna a Swift Academy