Swift Academy · Leçon

Énumérations indirectes et structures récursives

Construire des listes chaînées et des arbres avec des cas d’énumération indirects.

Énumérations indirectes et structures récursives est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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

Un cas d'énumération `indirect` stocke sa valeur associée derrière un pointeur, ce qui permet de créer des structures de données récursives comme les listes chaînées, les arbres et les arbres d'expressions.

Pourquoi `indirect` est nécessaire

Sans `indirect`, une énumération qui se référence elle-même aurait une taille infinie : ```swift enum List { case empty case node(T, List) // ❌ recursive without size bound } ``` `indirect` ajoute une allocation sur le tas ; la taille se limite donc à celle d'un pointeur.

Définir une énumération indirecte

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

Exemple d'arbre binaire

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

Fonction récursive sur une énumération indirecte

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

Hauteur de l'arbre

```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)) } } ```

Arbres d'expressions

```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` par cas

Vous pouvez marquer uniquement les cas récursifs avec `indirect` au lieu de marquer toute l'énumération : ```swift enum Tree { case leaf indirect case branch(left: Tree, value: T, right: Tree) } ``` Cette solution est plus précise : seul le cas récursif entraîne une allocation sur le tas.

Considération de performance

Les cas `indirect` sont alloués sur le tas. Pour les structures récursives où les performances sont critiques, envisagez plutôt d'utiliser une classe ou de faire référence à une représentation fondée sur un tableau.

Quand utiliser les énumérations `indirect`

Cas d'utilisation appropriés : • Listes chaînées et structures de données fonctionnelles • Arbres syntaxiques abstraits (analyseurs, calculatrices) • Hiérarchies de systèmes de fichiers • Représentations arborescentes JSON/XML Évitez-les lorsque les représentations fondées sur des tableaux sont plus efficaces pour le cache.

Vérification rapide

Qu'ajoute `indirect` à un cas d'énumération ?

Récapitulatif

Points essentiels : • `indirect enum` ou `indirect case` permet de créer des types récursifs • Cette construction est nécessaire, car les types valeur récursifs auraient une taille infinie • Utilisez-la pour les listes chaînées, les arbres et les AST • Parcourez ces structures avec des fonctions récursives et `switch` • `indirect` appliqué à un cas est plus précis que `indirect` appliqué à toute l'énumération Ensuite : modéliser des machines à états avec des énumérations.

Questions Fréquemment Posées

La leçon « Énumérations indirectes et structures récursives » est-elle gratuite ?

Oui — le texte complet de « Énumérations indirectes et structures récursives » 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 « Énumérations indirectes et structures récursives » ?

Construire des listes chaînées et des arbres avec des cas d’énumération indirects. 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 3 sur 4.

Combien de temps prend la leçon « Énumérations indirectes et structures récursives » ?

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

Valeurs brutes et CaseIterable
Valeurs associées pour des données riches
Énumérations indirectes et structures récursives
Modéliser des machines à états avec des énumérations

← Retour à Swift Academy