Swift Academy · Aula

Como o ARC conta referências

Entenda o que ARC faz em tempo de compilação, as chamadas retain/release e os ciclos de vida dos objetos.

Como o ARC conta referências é 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

A Contagem Automática de Referências (ARC) gerencia a memória das instâncias de classe. Entender como ela conta as referências ajuda você a escrever código sem vazamentos.

O que o ARC Faz

O ARC rastreia quantas referências *fortes* apontam para cada instância de classe. Quando a contagem chega a zero, ele chama `deinit` e libera a memória — automaticamente.

Referências Fortes

```swift var a: Dog? = Dog(name: "Rex") // count = 1 var b = a // count = 2 a = nil // count = 1 b = nil // count = 0 → deinit ```

O ARC É Determinado em Tempo de Compilação

O ARC insere chamadas de retenção e liberação em tempo de compilação — não em tempo de execução, como faz um coletor de lixo. Isso significa: • Não há pausas causadas pelo coletor de lixo • Desalocação determinística • Um pequeno custo no tamanho do código devido às chamadas de retenção e liberação

Risco de Ciclo de Referências Fortes

```swift class Node { var next: Node? } var n1: Node? = Node() var n2: Node? = Node() n1?.next = n2 n2?.next = n1 // cycle! n1 = nil; n2 = nil // both stuck at count=1 — leaked! ```

Contando com Várias Variáveis

```swift class Engine {} var car1: Engine? = Engine() // count = 1 var car2 = car1 // count = 2 var car3 = car2 // count = 3 car1 = nil // count = 2 car2 = nil // count = 1 // Engine still alive — car3 holds it car3 = nil // count = 0 → deinit ```

ARC em Coleções

```swift var dogs: [Dog] = [] dogs.append(Dog(name:"A")) // count = 1 dogs.append(Dog(name:"B")) // count = 1 each dogs.removeAll() // both deinit called ```

O ARC NÃO se Aplica a Tipos de Valor

Estruturas, enumerações e tuplas NÃO são contadas por referência: ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

Observando o ARC com deinit

```swift class Cat { let name: String init(name: String) { self.name = name; print("\(name) born") } deinit { print("\(name) deallocated") } } var c: Cat? = Cat(name: "Luna") c = nil // "Luna deallocated" printed ```

Desempenho: ARC vs. Coletor de Lixo

• Coletor de lixo: pausa a execução periodicamente para coletar; há um compromisso entre vazão e latência • ARC: desaloca imediatamente quando a contagem chega a 0; não há pausas • Sobrecarga do ARC: cada atribuição por meio de uma referência forte custa um par de retenção e liberação

Verificação Rápida

Quando o ARC chama `deinit` e libera a memória de um objeto?

Recapitulação

Principais conclusões: • O ARC rastreia referências fortes para instâncias de classe • Contagem 0 → `deinit` é chamado → memória liberada • O ARC é determinado em tempo de compilação — não há pausas do coletor de lixo • Tipos de valor (estrutura/enumeração) não são gerenciados pelo ARC • Ciclos impedem que a contagem chegue a 0 → use referências fracas ou não proprietárias A seguir: ciclos de retenção.

Perguntas Frequentes

A aula “Como o ARC conta referências” é grátis?

Sim — o texto completo de “Como o ARC conta referências” é 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 “Como o ARC conta referências”?

Entenda o que ARC faz em tempo de compilação, as chamadas retain/release e os ciclos de vida dos objetos. 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 “Como o ARC conta referências”?

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

Como o ARC conta referências
Ciclos de retenção: causas e detecção
Referências weak e unowned
Listas de captura de closures e [weak self]

← Voltar para Swift Academy