...
Eroare Swift · Erori fatale la rulare

Fatal error: Attempted to read an unowned reference but object 0x21b4f0 was already destroyed

Pe scurt

O referință unowned indică un obiect care a fost deja eliberat din memorie, iar tu încerci să-l folosești. Folosește o referință normală (puternică) dacă obiectul trebuie să trăiască, sau weak (opțională) dacă poate dispărea.

Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

Ce înseamnă

Swift eliberează un obiect (o instanță de clasă) când nu mai are nicio referință puternică (ARC). O referință unowned nu ține obiectul în viață: e o promisiune că obiectul va exista cât timp folosești referința. Dacă promisiunea e încălcată, adică obiectul a fost eliberat și tu citești totuși unowned, programul se oprește cu acest mesaj. Adresa (0x...) diferă la fiecare rulare.

Apare tipic când singura referință puternică era o variabilă locală dintr-o funcție: la ieșirea din funcție obiectul dispare, iar obiectul care îl ținea unowned rămâne cu o referință moartă. Mai apare în closure-uri cu [unowned self] care rulează după ce ecranul a fost închis.

Regula: unowned doar când celălalt obiect trăiește garantat cel puțin cât tine. Altfel, weak var (opțional, devine nil) sau o referință normală.

De ce apare: cauzele frecvente

1Obiectul referit unowned e creat local

Greșit
SWIFT
class Client { let nume = "Ana" }
class Comanda {
    unowned let client: Client
    init(client: Client) { self.client = client }
}
func creeaza() -> Comanda {
    Comanda(client: Client())
}
print(creeaza().client.nume)
Corect
SWIFT
class Client { let nume = "Ana" }
class Comanda {
    let client: Client
    init(client: Client) { self.client = client }
}
func creeaza() -> Comanda {
    Comanda(client: Client())
}
print(creeaza().client.nume)

Cu o referință puternică, comanda ține clientul în viață cât timp are nevoie de el.

2[unowned self] într-un closure care trăiește mai mult

Greșit
SWIFT
class Ecran {
    var titlu = "Profil"
    func handler() -> () -> String {
        return { [unowned self] in self.titlu }
    }
}
let h = Ecran().handler()
print(h())
Corect
SWIFT
class Ecran {
    var titlu = "Profil"
    func handler() -> () -> String {
        return { [weak self] in self?.titlu ?? "închis" }
    }
}
let h = Ecran().handler()
print(h())

Cu weak, după eliberarea ecranului self devine nil, iar closure-ul tratează cazul fără să oprească programul.

Repară tu

Repară eroarea, direct în pagină

Funcția creeazaComanda creează un client și o comandă care îl reține. Programul trebuie să afișeze Client: Ana, dar se oprește cu Attempted to read an unowned reference but object ... was already destroyed, pentru că clientul dispare la ieșirea din funcție. Fă ca, în Comanda, referința la client să țină clientul în viață.

Codul care dă eroarea
SWIFT
class Client {
    let nume: String
    init(nume: String) {
        self.nume = nume
    }
}

class Comanda {
    unowned let client: Client
    init(client: Client) {
        self.client = client
    }
}

func creeazaComanda() -> Comanda {
    let c = Client(nume: "Ana")
    return Comanda(client: c)
}

let comanda = creeazaComanda()
print("Client: \(comanda.client.nume)")
După reparație, programul afișează
Client: Ana
Indiciu

Scoate unowned de pe proprietatea client.

Alte forme ale mesajului

  • Fatal error: Attempted to read an unowned reference but object 0x600000c04000 was already deallocated
  • Thread 1: Fatal error: Attempted to read an unowned reference but object 0x600000c04000 was already deallocated

Cum o eviți pe viitor

  • Implicit, folosește referințe normale. Treci la weak doar ca să rupi un ciclu de referințe (delegate, părinte).
  • Folosește unowned doar când viața celuilalt obiect e garantat cel puțin la fel de lungă (de exemplu, un client și cardul lui).
  • În closure-uri care pot rula mai târziu (callback-uri de rețea, timere), preferă [weak self].

Întrebări frecvente

Care e diferența dintre weak și unowned?

Ambele nu țin obiectul în viață. weak e mereu opțional și devine nil automat când obiectul dispare. unowned nu e opțional: dacă obiectul a dispărut, citirea oprește programul.

De ce s-ar folosi unowned, dacă e riscant?

Când știi sigur că obiectul există, unowned evită despachetarea opționalului la fiecare folosire. Dar câștigul e mic, iar riscul e o oprire bruscă, deci în caz de dubiu folosește weak.

Erori înrudite

← Toate erorile Swift

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Învață Swift de la zero, cu exerciții la fiecare lecție

Curs Swift (iOS): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.