0Pricing
Swift Academy · Aula

Fundamentos de ARC: strong / weak / unowned

Aprenda a contagem de referências do ARC e quando usar strong , weak e unowned para evitar vazamentos de memória.

Fundamentos de ARC: strong / weak / unowned é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

ARC em um minuto

O Swift usa ARC (contagem automática de referências). Cada referência forte aumenta a contagem de uma instância de classe. Quando ela chega a zero, deinit é executado e a memória é liberada.

Forte por padrão

Forte é o padrão. Quando a última referência forte desaparece, deinit é chamado.

final class Person {
    let name: String
    init(_ name: String) { self.name = name; print("init:", name) }
    deinit { print("deinit:", name) }
}

var p: Person? = Person("Ada")
p = nil  // ARC count -> 0, triggers deinit

Exemplo de ciclo

Referências fortes nos dois sentidos criam um ciclo de retenção. O ARC não consegue liberá-las, causando um vazamento.

final class A {
    var b: B?
    deinit { print("A deinit") }
}
final class B {
    var a: A?
    deinit { print("B deinit") }
}

var a: A? = A()
var b: B? = B()
a?.b = b      // strong
b?.a = a      // strong

a = nil       // no deinit (cycle)
b = nil       // still no deinit (leak)

Referência fraca

Torne um dos lados fraco para evitar o ciclo. Referências fracas são opcionais e se tornam nil automaticamente quando o objeto é desalocado.

final class A2 {
    weak var b: B2?   // weak breaks the strong cycle
    deinit { print("A2 deinit") }
}
final class B2 {
    var a: A2?
    deinit { print("B2 deinit") }
}

var a2: A2? = A2()
var b2: B2? = B2()
a2?.b = b2   // weak
b2?.a = a2   // strong

a2 = nil     // A2 deinit runs
b2 = nil     // B2 deinit runs

Referência não proprietária

Use não proprietária quando o objeto referenciado sobreviverá a esta referência. Ela é não opcional e não recebe nil; acessá-la após a desalocação causa uma falha — portanto, garanta os tempos de vida.

final class Customer {
    let name: String
    var card: CreditCard?
    init(_ name: String) { self.name = name }
    deinit { print("Customer deinit") }
}
final class CreditCard {
    unowned let owner: Customer   // never optional; owner must outlive card
    init(owner: Customer) { self.owner = owner }
    deinit { print("CreditCard deinit") }
}

var cust: Customer? = Customer("Lars")
cust!.card = CreditCard(owner: cust!)
cust = nil  // deallocates both (no cycle)

Dicas e padrões

Dicas:

  • Use forte por padrão.
  • Rompa ciclos com fraca (delegados geralmente são fracos).
  • Use não proprietária somente quando o tempo de vida for garantido (por exemplo, filho → owner).
  • Classes são tipos de referência; estruturas/enumerações não precisam das regras do ARC.

Fraca versus não proprietária?

Verificação rápida: quando escolher fraca em vez de não proprietária?

Recapitulação

Recapitulação: o ARC libera objetos quando não restam referências fortes. Evite ciclos com fraca (opcional) ou não proprietária (tempo de vida garantido). Escolha a menor forma segura de posse.

Perguntas Frequentes

A aula “Fundamentos de ARC: strong / weak / unowned” é grátis?

Sim — o texto completo de “Fundamentos de ARC: strong / weak / unowned” é 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 3 aulas no total.

O que vou aprender em “Fundamentos de ARC: strong / weak / unowned”?

Aprenda a contagem de referências do ARC e quando usar strong , weak e unowned para evitar vazamentos de memória. 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 3.

Quanto tempo leva a aula “Fundamentos de ARC: strong / weak / unowned”?

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

  1. Fundamentos de ARC: strong / weak / unowned
  2. Ciclos de retenção e como rompê-los com weak/unowned
  3. Tipos de valor para reduzir o compartilhamento
← Voltar para Swift Academy