Swift Academy · Lezione

Enum indirect e strutture ricorsive

Creare liste concatenate e alberi con casi enum indirect.

Enum indirect e strutture ricorsive è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 3 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

Un caso di enum `indirect` memorizza il proprio valore associato dietro un puntatore, consentendo strutture dati ricorsive come liste concatenate, alberi e alberi di espressioni.

Perché è necessario indirect

Senza `indirect`, un enum che fa riferimento a sé stesso avrebbe dimensione infinita: ```swift enum List { case empty case node(T, List) // ❌ recursive without size bound } ``` `indirect` aggiunge un'allocazione nell'heap, quindi la dimensione si riduce a quella di un puntatore.

Definire un enum indirect

```swift indirect enum List { case empty case node(T, List) } let list = List.node(1, .node(2, .node(3, .empty))) // [1, 2, 3] ```

Esempio di albero binario

```swift indirect enum Tree { case leaf case branch(left: Tree, value: T, right: Tree) } let t = Tree.branch(left: .leaf, value: 5, right: .branch(left:.leaf, value:10, right:.leaf)) ```

Funzione ricorsiva su un enum indirect

```swift func sum(_ list: List) -> Int { switch list { case .empty: return 0 case .node(let value, let rest): return value + sum(rest) } } print(sum(list)) // 6 ```

Altezza dell'albero

```swift func height(_ tree: Tree) -> Int { switch tree { case .leaf: return 0 case .branch(let l, _, let r): return 1 + max(height(l), height(r)) } } ```

Alberi di espressioni

```swift indirect enum Expr { case num(Double) case add(Expr, Expr) case mul(Expr, Expr) } func eval(_ e: Expr) -> Double { switch e { case .num(let n): return n case .add(let a, let b): return eval(a) + eval(b) case .mul(let a, let b): return eval(a) * eval(b) } } print(eval(.mul(.num(2), .add(.num(3), .num(4))))) // 14 ```

indirect per singolo caso

È possibile contrassegnare solo i casi ricorsivi con `indirect`, invece dell'intero enum: ```swift enum Tree { case leaf indirect case branch(left: Tree, value: T, right: Tree) } ``` È una soluzione più precisa: solo il caso ricorsivo comporta un'allocazione nell'heap.

Considerazioni sulle prestazioni

I casi `indirect` vengono allocati nell'heap. Per le strutture ricorsive in cui le prestazioni sono fondamentali, si può valutare l'uso di una classe o di una rappresentazione basata su array.

Quando usare gli enum indirect

Casi d'uso adatti: • Liste concatenate e strutture dati funzionali • Alberi di sintassi astratta (parser, calcolatori) • Gerarchie di file system • Rappresentazioni ad albero di JSON/XML Da evitare quando le rappresentazioni basate su array piatti offrono una migliore efficienza della cache.

Verifica rapida

Che cosa aggiunge `indirect` a un caso di enum?

Riepilogo

Concetti chiave: • `indirect enum` o `indirect case` consente di definire tipi ricorsivi • È necessario perché i tipi valore ricorsivi avrebbero dimensione infinita • Si usa per liste concatenate, alberi e AST • Si attraversano con funzioni ricorsive e switch • `indirect` applicato a un singolo caso è più preciso di `indirect` applicato all'intero enum Prossimo argomento: modellare macchine a stati con gli enum.

Domande Frequenti

La lezione «Enum indirect e strutture ricorsive» è gratuita?

Sì — il testo completo di «Enum indirect e strutture ricorsive» è 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 «Enum indirect e strutture ricorsive»?

Creare liste concatenate e alberi con casi enum indirect. 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 3 di 4.

Quanto tempo richiede la lezione «Enum indirect e strutture ricorsive»?

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

← Torna a Swift Academy