Swift Academy · Aula

Enums indiretos e estruturas recursivas

Crie listas encadeadas e árvores com casos de enum indirect.

Enums indiretos e estruturas recursivas é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Boas-vindas

Uma enumeração `indirect` armazena seu valor associado atrás de um ponteiro, permitindo estruturas de dados recursivas, como listas encadeadas, árvores e árvores de expressões.

Por que o modo indireto é necessário

Sem `indirect`, uma enumeração que referencia a si mesma teria tamanho infinito: ```swift enum List { case empty case node(T, List) // ❌ recursive without size bound } ``` `indirect` adiciona uma alocação na memória dinâmica, para que o tamanho seja apenas o de um ponteiro.

Definindo uma enumeração indireta

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

Exemplo de árvore binária

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

Função recursiva em uma enumeração indireta

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

Altura da árvore

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

Árvores de expressões

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

indireto por caso

Você pode marcar apenas os casos recursivos como `indirect`, em vez da enumeração inteira: ```swift enum Tree { case leaf indirect case branch(left: Tree, value: T, right: Tree) } ``` Isso é mais preciso — somente o caso recursivo incorre na alocação na memória dinâmica.

Consideração de desempenho

Os casos `indirect` são alocados na memória dinâmica. Para estruturas recursivas críticas para o desempenho, considere usar uma classe ou, em vez disso, referenciar uma representação baseada em vetor.

Quando usar enumerações indiretas

Bons casos de uso: • Listas encadeadas e estruturas de dados funcionais • Árvores sintáticas abstratas (analisadores, calculadoras) • Hierarquias de sistemas de arquivos • Representações em árvore de JSON/XML Evite quando representações planas baseadas em vetores forem mais eficientes para a memória cache.

Verificação rápida

O que `indirect` adiciona a um caso de enumeração?

Recapitulação

Principais conclusões: • `indirect enum` ou `indirect case` habilita tipos recursivos • É necessário porque tipos recursivos por valor teriam tamanho infinito • Use para listas encadeadas, árvores e árvores sintáticas abstratas • Percorra-os com funções recursivas e `switch` • `indirect` por caso é mais preciso do que `indirect` para a enumeração inteira Próximo: modelagem de máquinas de estados com enumerações.

Perguntas Frequentes

A aula “Enums indiretos e estruturas recursivas” é grátis?

Sim — o texto completo de “Enums indiretos e estruturas recursivas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Enums indiretos e estruturas recursivas”?

Crie listas encadeadas e árvores com casos de enum indirect. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Enums indiretos e estruturas recursivas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Valores brutos e CaseIterable
Valores associados para dados mais completos
Enums indiretos e estruturas recursivas
Modelagem de máquinas de estados com enums

← Voltar para Swift Academy