Lição 37: Tipos Box (Contêineres de Armazenamento)

1. Narrativa

O mecha Æther precisa armazenar componentes de tamanhos variados em slots padronizados — Contêineres de Armazenamento são como Box<T>, que aloca dados no heap enquanto mantém um ponteiro leve na stack. O piloto usa Box para criar estruturas recursivas como árvores de sistemas e transferir ownership de componentes pesados.

2. Conceito

Box<T> é o smart pointer mais simples de Rust — aloca o valor no heap e mantém um ponteiro na stack:

• Alocação heap: Box::new(valor) move o valor para o heap
• Tamanho fixo: Na stack, Box<T> sempre tem tamanho de um ponteiro (8 bytes)
• Tipos recursivos: Permite structs que se referenciam (árvores, listas ligadas)
• Ownership único: Box segue regras normais de ownership — um dono, move sem ser Copy
• Deref transparente: Acessa o valor interno sem sintaxe especial

3. Requisitos

• Criar valores com Box::new()
• Construir tipo recursivo (árvore binária) com Box
• Iterar e buscar em Vec<Box<T>>
• Transferir ownership de valores boxed

4. Design de Dados

graph TD
    A[Stack: Box ptr] -->|aponta para| B[Heap: Componente]
    B --> C[nome: String]
    B --> D[peso: i32]
    E[Stack: NoSistema] -->|esquerda| F[Box ptr]
    E -->|direita| G[Box ptr]
    F --> H[Heap: NoSistema]
    G --> I[Heap: NoSistema]

5. Diagrama de Fluxo

flowchart TD
    A[Início] --> B{Nó existe?}
    B -->|Não| C[Retornar 0]
    B -->|Sim| D[Contar nó atual: 1]
    D --> E[Recursão: esquerda]
    E --> F[Recursão: direita]
    F --> G[Somar: 1 + esq + dir]
    G --> H[Retornar total]
    C --> I[Fim]
    H --> I

6. Funções

Função	Descrição
criar_componente	Cria Box<Componente> no heap
criar_folha	Cria nó folha de árvore binária
criar_no	Cria nó com dois filhos (recursivo)
contar_nos	Conta nós em árvore via recursão
peso_total	Soma peso de Vec<Box<Componente>>
mais_pesado	Encontra componente mais pesado
transferir	Move Box de Vec (ownership transfer)
buscar_id	Busca ID em árvore recursiva

7. Exemplo

// Box para alocação heap
let reator = Box::new(Componente { nome: "Reator".into(), peso: 500 });

// Tipo recursivo — Box é necessário
let arvore = criar_no(1,
    criar_folha(2),
    criar_folha(3)
);

// Ownership transfer
let mut lista = vec![Box::new(Componente { nome: "Arma".into(), peso: 300 })];
let removido = lista.pop();

8. Missão

1. Implementar criar_componente com Box::new()
2. Implementar criar_folha — nó sem filhos
3. Implementar criar_no — nó com dois filhos Box
4. Implementar contar_nos com recursão sobre Option<Box<NoSistema>>
5. Implementar peso_total iterando sobre &[Box<Componente>]
6. Implementar mais_pesado usando .iter().max_by_key()
7. Implementar transferir com .remove() ou .swap_remove()
8. Implementar buscar_id com recursão em árvore

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• Box::new(x) move x para o heap — x não é mais acessível diretamente
• Tipos recursivos SEMPRE precisam de indireção (Box, Referência, etc.)
• Box<T> implementa Deref<Target=T> — use *box_val para dereferenciar
• Ownership de Box segue as mesmas regras de qualquer valor Rust