Vertel over de levenscyclus van een object in iOS…

De levenscyclus van een object in iOS wordt beheerd door het referentietellingsmechanisme (Reference Counting). De meest gebruikelijke methode is Automatic Reference Counting (ARC).

Fases van de levenscyclus:

Creatie (Creation): Het object wordt gemaakt door de initialisatie van de klasse. De referentieteller wordt op 1 gezet.
```
// Initialisatie van een object van de klasse MyClass
let myObject = MyClass() 
```
Gebruik (Usage): Het object wordt in de applicatie gebruikt. Andere objecten kunnen er referenties naar krijgen, waardoor de referentieteller wordt verhoogd.
```
// Een ander object krijgt een referentie
anotherObject.referenceToMyObject = myObject 
// De referentieteller van myObject wordt verhoogd
```
Deallocatie (Deallocation): Wanneer de referentieteller van het object op nul komt, roept de runtime automatisch de methode deinit() aan (voor Objective-C klassen dealloc). Het object vrijmaakt het gebruikte geheugen.
```
deinit {
    // Code om resources vrij te maken
    print("Object is verwijderd")
}
```

Problemen en oplossingen:

Retain Cycles (Sterke referentiecycli): Ontstaan wanneer twee of meer objecten sterke referenties naar elkaar hebben. De referentieteller van elk object bereikt nooit nul, en de objecten worden niet gedeinitialiseerd.
Oplossingen:
- Weak References: Worden aangegeven met het sleutelwoord weak. Verhogen de referentieteller niet. Worden gebruikt voor referenties naar ouderobjecten of delegaten, wanneer de relatie tijdelijk of optioneel is.
- Unowned References: Worden aangegeven met unowned. Verhogen de referentieteller niet. Worden gebruikt wanneer de gerelateerde objecten altijd een vergelijkbare levenscyclus hebben, en de referentie gegarandeerd niet nil zal zijn op het moment van gebruik. Als het object waarnaar de unowned referentie verwijst wordt gedeinitialiseerd, leidt een poging tot toegang tot die referentie tot een runtime-fout.

Voorbeeld van weak en unowned in closures om sterke referentiecycli te voorkomen:

class Person {
    let name: String
    // Zwakke referentie naar closure om cyclus te voorkomen
    var greeting: (() -> Void)? 

    init(name: String) {
        self.name = name
        // Capture self als weak reference
        greeting = { [weak self] in 
            guard let self = self else { return }
            print("Hallo, \(self.name)!")
        }
    }

    deinit {
        print("\(name) wordt gedeinitialiseerd")
    }
}

class Apartment {
    let unit: String
    // Zwakke referentie naar huurder
    weak var tenant: Person? 

    init(unit: String) {
        self.unit = unit
    }

    deinit {
        print("Appartement \(unit) wordt gedeinitialiseerd")
    }
}

Een correcte referentiebeheer is cruciaal om geheugenlekken te voorkomen en de stabiliteit van de applicatie te behouden.

Vertel over de levenscyclus van een object in iOS.