Mondja el egy objektum életciklusát az iOS-ben.

Az iOS objektum életciklusa a Reference Counting mechanizmusával van kezelve. A leggyakoribb módszer az Automatikus Referenciaszámlálás (ARC).

Életciklus szakaszai:

Létrehozás (Creation): Az objektum az osztály inicializálásával jön létre. A referenciaszámláló 1-re van állítva.
```
// Egy MyClass osztály példányának inicializálása
let myObject = MyClass() 
```
Használat (Usage): Az objektum az alkalmazásban kerül használatra. Más objektumok hivatkozhatnak rá, növelve a referenciaszámlálót.
```
// Egy másik objektum hivatkozik rá
anotherObject.referenceToMyObject = myObject 
// myObject referenciaszámlálója növekszik
```
Deallocation (Felszabadítás): Amikor az objektum referenciaszámlálója nullára csökken, a runtime automatikusan meghívja a deinit() metódust (Objective-C osztályoknál dealloc). Az objektum felszabadítja a foglalt memóriát.
```
deinit {
    // Erőforrások felszabadítása
    print("Objektum megszűnt")
}
```

Problémák és megoldások:

Retain Cycles (Erős hivatkozási ciklusok): Akkor fordulnak elő, amikor két vagy több objektum erős hivatkozásokat tart fenn egymásra. Minden objektum referenciaszámlálója soha nem ér el nullát, így nem kerülnek felszabadításra.
Megoldások:
- Weak References (Gyenge hivatkozások): A weak kulcsszóval jelöltek. Nem növelik a referenciaszámlálót. Ideálisak ideiglenes vagy opcionális kapcsolatokhoz szülőobjektumok vagy delegáltak esetében.
- Unowned References (Sajátatlan hivatkozások): A unowned kulcsszóval jelöltek. Nem növelik a referenciaszámlálót. Akkor használják, amikor a kapcsolódó objektumok mindig ugyanazon életciklusban vannak, és a hivatkozás garantáltan nem lesz nil a használat pillanatában. Ha az unowned hivatkozás által hivatkozott objektum felszabadul, a hozzáférés ilyen hivatkozáshoz futási időben hibát okoz.

Példa weak és unowned hivatkozásokra záradékokban a erős hivatkozási ciklusok elkerülése érdekében:

class Person {
    let name: String
    // Gyenge hivatkozás a záradék elkerülése érdekében
    var greeting: (() -> Void)? 

    init(name: String) {
        self.name = name
        // self gyenge hivatkozásként való megfogása
        greeting = { [weak self] in 
            guard let self = self else { return }
            print("Helló, \(self.name)!")
        }
    }

    deinit {
        print("\(name) felszabadult")
    }
}

class Apartment {
    let unit: String
    // Gyenge hivatkozás a bérlőre
    weak var tenant: Person? 

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

    deinit {
        print("Lakás \(unit) felszabadult")
    }
}

A helyes hivatkozáskezelés kulcsfontosságú a memória szivárgások megelőzése és az alkalmazás stabilitásának fenntartása érdekében.