Millised on Swiftis viited?

Swiftil on kolm peamist viisi viiteid:

1. Tugev Viide (Strong Reference):

   • Suurendab objekti viidete loenduri.
   • Takistab objekti deallokatsiooni, kuni on vähemalt üks tugev viide.
   • On Swiftis vaikimisi viidetüüp.
   • Peamine tugevate viidete tsüklite tekkimise põhjus.

2. Nõrk Viide (Weak Reference):

   • Ei suurenda viidete loendurit.
   • Lubab objekti deallokatsiooni, kui sellele ei ole enam tugevaid viiteid.
   • Deklareerib weak sõnaga.
   • Alati on valikuline (Optional), kuna viide võib olla nil.
   • Kasutatakse tugevate viidete tsüklite vältimiseks, kui üks objekt võib eksisteerida sõltumatult teisest.

   class Person {
       let name: String
       weak var apartment: Apartment? // Nõrk viide
       init(name: String) {
           self.name = name
       }
       deinit { print("\(name) deallocated") }
   }
   
   class Apartment {
       let unit: String
       var tenant: Person? // Tavaline tugev viide
       init(unit: String) {
           self.unit = unit
       }
       deinit { print("Korter \(unit) deallocated") }
   }
   
   var john: Person?
   var unit4A: Apartment?
   
   john = Person(name: "John Appleseed")
   unit4A = Apartment(unit: "4A")
   
   john!.apartment = unit4A
   unit4A!.tenant = john // Siin võiks tekkida tugevate viidete tsükkel ilma `weak`-ita
   
   // Viited nullitakse, objektid deallokatsioonitakse
   john = nil
   unit4A = nil
   

3. Mitteomane Viide (Unowned Reference):

   • Ei suurenda viidete loendurit.
   • Lubab objekti deallokatsiooni, kui sellele ei ole enam tugevaid viiteid.
   • Deklareerib unowned sõnaga.
   • Ei ole valikuline. Eeldatakse, et viidatud objekt eksisteerib alati, kuni eksisteerib selle viidete objekt.
   • Kasutamine, kui üks objekt peab alati eksisteerima, kuni teine objekt eksisteerib (CreditCard alati kuulub Customer-ile).
   • Kui kasutatakse juba deallokitud objektiga, põhjustab see jooksveate (crash).
   • Kasutatakse tugevate viidete tsüklite vältimiseks, kui üks objekt peab alati eksisteerima, kuni teine, ja ei ole võimalik, et üks neist muutub nil-ks (näiteks self sidumine sulgudes).

   class Customer {
       let name: String
       var card: CreditCard?
       init(name: String) {
           self.name = name
       }
       deinit { print("\(name) deallocated") }
   }
   
   class CreditCard {
       let number: UInt64
       unowned let customer: Customer // Mitteomane viide
       init(number: UInt64, customer: Customer) {
           self.number = number
           self.customer = customer
       }
       deinit { print("Kaart #\(number) deallocated") }
   }
   
   var john: Customer? = Customer(name: "John Appleseed")
   john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
   
   // Kui klient tühjendatakse, muutub kaart, mis sellele viitab unowned-iga,
   // kehtetuks, kuid tsüklit see ei tekita.
   john = nil // Mõlemad objektid deallokatsioonitakse
   

Valik weak ja unowned sõltub objektide vahelise suhte iseloomust: kasutage weak, kui üks objekt võib eksisteerida ilma teiseta (Person ilma Apartment-ita), ja unowned, kui üks objekt alati peab eksisteerima, kuni teine eksisteerib (CreditCard alati kuulub Customer-ile).