Swift Academy · Lezione

Stack e heap: dove risiedono i valori

Come le struct risiedono nello stack e le classi nell’heap, con le relative implicazioni sulle prestazioni.

Stack e heap: dove risiedono i valori è 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.

Benvenuto

Capire dove risiedono in memoria i valori Swift, nello stack o nell'heap, è essenziale per scrivere codice efficiente e prevedibile.

Lo stack

Lo stack è un'area contigua di memoria gestita automaticamente: • Le variabili locali e i parametri delle funzioni risiedono qui • L'allocazione è O(1): basta spostare un puntatore • La memoria viene liberata automaticamente all'uscita dall'ambito • È locale al thread: ogni thread ha il proprio stack

L'heap

L'heap è un'area condivisa destinata alle allocazioni di lunga durata: • Gli oggetti risiedono qui quando la loro durata supera quella di un singolo ambito • L'allocazione richiede la ricerca di memoria libera, quindi è più costosa • Per le classi è gestita da ARC • È condivisa tra i thread e richiede la sincronizzazione

Le struct risiedono nello stack

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Le struct piccole vengono passate per copia, senza costi aggiuntivi sull'heap.

Le classi risiedono nell'heap

```swift class Dog { var name: String init(name: String) { self.name = name } } var d = Dog(name: "Rex") // Dog instance on heap // 'd' is a pointer on the stack ```

Le struct grandi possono usare l'heap

Le struct grandi (array, stringhe e tipi valore di grandi dimensioni) usano internamente il COW e la memoria sull'heap, pur comportandosi come tipi valore: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Cattura nelle closure

Quando una closure cattura una variabile di tipo valore che deve sopravvivere all'ambito, Swift la inserisce in un box sull'heap: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Boxing dei protocolli esistenziali

Memorizzare piccoli tipi valore in variabili `any Protocol` può causare un'allocazione sull'heap (boxing esistenziale): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` I tipi piccoli (≤3 word) vengono memorizzati inline; quelli più grandi vengono inseriti in un box.

Misurare le allocazioni

Usi il modello Allocations di Instruments per visualizzare le allocazioni sull'heap: 1. Profiling > Allocations 2. Filtri per classe o categoria 3. Tieni traccia del numero di `alloc` e `dealloc` Un numero elevato di allocazioni nei cicli indica spesso un boxing imprevisto.

Implicazioni progettuali

• Preferisca le struct per i tipi che contengono dati di breve durata: velocità dello stack • Usi le classi quando servono identità o stato condiviso • Eviti le allocazioni nei cicli stretti: pre-allochi con `reserveCapacity` • Esegua il profiling prima di ottimizzare: l'ottimizzazione prematura fa perdere tempo

Verifica rapida

Quale tipo di memoria viene liberato automaticamente quando si esce dall'ambito di una funzione?

Riepilogo

Punti chiave: • Stack: economico, automatico, locale al thread, usato dai tipi valore • Heap: flessibile, gestito da ARC, usato dai tipi riferimento • Le struct grandi usano buffer interni sull'heap (COW) • Le closure che catturano variabili le inseriscono in box sull'heap • Usi Instruments Allocations per individuare una pressione imprevista sull'heap Successivo: mutazione, condivisione e aliasing imprevisto.

Domande Frequenti

La lezione «Stack e heap: dove risiedono i valori» è gratuita?

Sì — il testo completo di «Stack e heap: dove risiedono i valori» è 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 «Stack e heap: dove risiedono i valori»?

Come le struct risiedono nello stack e le classi nell’heap, con le relative implicazioni sulle prestazioni. 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 «Stack e heap: dove risiedono i valori»?

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

Stack e heap: dove risiedono i valori
Mutazione, condivisione e aliasing imprevisto
Grafi misti di valori e riferimenti
Progettare API con semantica dei valori

← Torna a Swift Academy