Opowiedz o cyklu życia obiektu w iOS.

Cykl życia obiektu w iOS jest zarządzany przez mechanizm zliczania odwołań (Reference Counting). Najczęściej stosowaną metodą jest Automatyczne Zliczanie Odwołań (ARC).

Etapy cyklu życia:

Tworzenie (Creation): Obiekt jest tworzony przez inicjalizację klasy. Licznik odwołań jest ustawiany na 1.
```
// Inicjalizacja obiektu klasy MyClass
let myObject = MyClass() 
```

Użycie (Usage): Obiekt jest używany w aplikacji. Inne obiekty mogą uzyskać do niego odwołania, zwiększając licznik odwołań.

// Inny obiekt uzyskuje odwołanie
anotherObject.referenceToMyObject = myObject 
// Licznik odwołań myObject się zwiększa

Deallocation (Deallocation): Gdy licznik odwołań obiektu osiąga zero, środowisko uruchomieniowe automatycznie wywołuje metodę deinit() (dla klas Objective-C - dealloc). Obiekt zwalnia zajmowaną pamięć.
```
deinit {
    // Kod zwalniający zasoby
    print("Obiekt został zniszczony")
}
```

Problemy i rozwiązania:

Cykl referencyjny (Retain Cycles): Powstaje, gdy dwa lub więcej obiektów mają silne odwołania do siebie. Licznik odwołań każdego obiektu nigdy nie osiąga zera, a obiekty nie są deinitializowane.
Rozwiązania:
- Słabe odwołania (Weak References): Są oznaczane słowem kluczowym weak. Nie zwiększają licznika odwołań. Używa się ich do odwołań do obiektów nadrzędnych lub delegatów, gdy relacja jest tymczasowa lub opcjonalna.
- Nieposiadane odwołania (Unowned References): Są oznaczane słowem kluczowym unowned. Nie zwiększają licznika odwołań. Używa się ich, gdy powiązane obiekty mają zawsze taki sam cykl życia, a odwołanie nie będzie nil w momencie użycia. Jeśli obiekt, na który wskazuje odwołanie unowned, zostanie deinitializowany, próba dostępu do takiego odwołania spowoduje błąd w czasie działania.

Przykład weak i unowned w zamknięciach, aby uniknąć cykli silnych odwołań:

class Person {
    let name: String
    // Słabe odwołanie do zamknięcia, aby uniknąć cyklu
    var greeting: (() -> Void)? 

    init(name: String) {
        self.name = name
        // Uchwyć self jako słabe odwołanie
        greeting = { [weak self] in 
            guard let self = self else { return }
            print("Cześć, \(self.name)!")
        }
    }

    deinit {
        print("\(name) jest deinitializowany")
    }
}

class Apartment {
    let unit: String
    // Słabe odwołanie do najemcy
    weak var tenant: Person? 

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

    deinit {
        print("Mieszkanie \(unit) jest deinitializowane")
    }
}

Poprawne zarządzanie odwołaniami jest kluczowe, aby zapobiec wyciekom pamięci i zapewnić stabilność aplikacji.