Swift Academy · Aula

Pilha e heap: onde os valores vivem

Entenda como as estruturas vivem na pilha e as classes no heap, além das implicações de desempenho.

Pilha e heap: onde os valores vivem é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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

Entender onde os valores do Swift ficam na memória — na pilha ou na memória dinâmica — é essencial para escrever código eficiente e previsível.

A pilha

A pilha é um bloco contíguo de memória gerenciado automaticamente: • Variáveis locais e parâmetros de funções ficam aqui • A alocação é O(1) — basta mover um ponteiro • É liberada automaticamente quando o escopo termina • É local à linha de execução — cada linha de execução tem sua própria pilha

A memória dinâmica

A memória dinâmica é um espaço compartilhado para alocações de longa duração: • Os objetos ficam aqui quando seu tempo de vida ultrapassa um escopo • A alocação exige encontrar memória livre — é mais dispendiosa • É gerenciada por ARC para classes • É compartilhada entre linhas de execução — exige sincronização

As estruturas vivem na pilha

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Estruturas pequenas são passadas por cópia — sem sobrecarga na memória dinâmica.

As classes vivem na memória dinâmica

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

Estruturas grandes podem usar a memória dinâmica

Estruturas grandes (matrizes, cadeias de caracteres e tipos de valor grandes) usam COW e armazenamento na memória dinâmica internamente, embora se comportem como tipos de valor: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Captura em fechamentos

Quando um fechamento captura uma variável de tipo de valor que precisa sobreviver ao escopo, o Swift a coloca em uma caixa na memória dinâmica: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Encapsulamento existencial de protocolos

Armazenar tipos de valor pequenos em variáveis `any Protocol` pode causar alocação na memória dinâmica (encapsulamento existencial): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` Tipos pequenos (≤3 palavras) são armazenados diretamente; tipos maiores são colocados em caixas.

Medindo alocações

Use o modelo Allocations do Instruments para visualizar as alocações na memória dinâmica: 1. Profile > Allocations 2. Filtre por classe ou categoria 3. Acompanhe as contagens de `alloc` e `dealloc` Contagens altas de alocação em laços geralmente indicam encapsulamento inesperado.

Implicações de projeto

• Prefira estruturas para tipos de curta duração que armazenam dados — velocidade da pilha • Use classes quando for necessária identidade ou estado compartilhado • Evite alocar em laços apertados — pré-aloque com `reserveCapacity` • Faça o perfil antes de otimizar — a otimização prematura desperdiça tempo

Verificação rápida

Que tipo de memória é liberado automaticamente quando o escopo de uma função termina?

Recapitulação

Principais conclusões: • Pilha: barata, automática, local à linha de execução, tipos de valor • Memória dinâmica: flexível, gerenciada por ARC, tipos de referência • Estruturas grandes usam buffers internos na memória dinâmica (COW) • Fechamentos que capturam variáveis as colocam em caixas na memória dinâmica • Use Instruments Allocations para detectar pressão inesperada sobre a memória dinâmica Próximo: mutação, compartilhamento e referências inesperadas.

Perguntas Frequentes

A aula “Pilha e heap: onde os valores vivem” é grátis?

Sim — o texto completo de “Pilha e heap: onde os valores vivem” é 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 “Pilha e heap: onde os valores vivem”?

Entenda como as estruturas vivem na pilha e as classes no heap, além das implicações de desempenho. 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 1 de 4.

Quanto tempo leva a aula “Pilha e heap: onde os valores vivem”?

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

Pilha e heap: onde os valores vivem
Mutação, compartilhamento e aliasing inesperado
Grafos mistos de valores e referências
Design de APIs para semântica de valores

← Voltar para Swift Academy