Belajar Swift : Contoh Program ARC Overview di Swift dan Fungsinya - Masnaato
Skip to content Skip to sidebar Skip to footer

Belajar Swift : Contoh Program ARC Overview di Swift dan Fungsinya

Cara ARC Overview di Swift



Fungsi manajemen memori dan penggunaannya ditangani dalam bahasa Swift 4 melalui Penghitungan referensi otomatis (ARC). ARC digunakan untuk menginisialisasi dan deinisialisasi sumber daya sistem sehingga melepaskan ruang memori yang digunakan oleh instance kelas saat instance tidak lagi diperlukan. ARC melacak informasi tentang hubungan antara contoh kode kami untuk mengelola sumber daya memori secara efektif.

Fungsi ARC

  • ARC mengalokasikan sebagian memori untuk menyimpan informasi setiap kali instance kelas baru dibuat oleh init ().

  • Informasi tentang jenis instans dan nilainya disimpan dalam memori.

  • Ketika instance kelas tidak lagi diperlukan, secara otomatis mengosongkan ruang memori oleh deinit () untuk penyimpanan dan pengambilan instance kelas lebih lanjut.

  • ARC terus melacak properti, konstanta, dan variabel instance kelas yang saat ini merujuk sehingga deinit () hanya diterapkan ke instance yang tidak digunakan tersebut.

  • ARC mempertahankan 'referensi yang kuat' ke properti instance kelas tersebut, konstanta, dan variabel untuk membatasi alokasi saat instance kelas sedang digunakan.

Program ARC

class StudDetails {
   var stname: String!
   var mark: Int!
   
   init(stname: String, mark: Int) {
      self.stname = stname
      self.mark = mark
   }
   deinit {
      print("Deinitialized \(self.stname)")
      print("Deinitialized \(self.mark)")
   }
}

let stname = "Swift 4"
let mark = 98

print(stname)
print(mark)

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

Swift 4
98

Instans Kelas Siklus Referensi Kuat ARC

class studmarks {
   let name: String
   var stud: student?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

class student {
   let name: String
   var strname: studmarks?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

var shiba: studmarks?
var mari: student?

shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")

shiba!.stud = mari
mari!.strname = shiba

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

Initializing: Swift 4
Initializing: ARC

Referensi ARC Lemah dan Tidak Terkenal

Properti tipe kelas memiliki dua cara untuk menyelesaikan siklus referensi yang kuat -

  • Referensi yang Lemah
  • Referensi Tak Bernaung

Referensi ini digunakan untuk mengaktifkan satu contoh untuk merujuk contoh lain dalam siklus referensi. Kemudian contoh dapat merujuk ke masing-masing dan setiap contoh alih-alih peduli tentang siklus referensi yang kuat. Ketika pengguna mengetahui bahwa beberapa instance dapat mengembalikan nilai 'nil', kami dapat menunjukkannya menggunakan referensi yang lemah. Ketika instance akan mengembalikan sesuatu daripada nihil, maka deklarasikan dengan referensi yang tidak berpemilik.

Program Referensi yang Lemah

class module {
   let name: String
   init(name: String) { self.name = name }
   var sub: submodule?
   deinit { print("\(name) Is The Main Module") }
}

class submodule {
   let number: Int
   init(number: Int) { self.number = number }
   weak var topic: module?

   deinit { print("Sub Module with its topic number is \(number)") }
}

var toc: module?
var list: submodule?
toc = module(name: "ARC")
list = submodule(number: 4)
toc!.sub = list
list!.topic = toc

toc = nil
list = nil

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

ARC Is The Main Module
Sub Module with its topic number is 4

Program Referensi Tidak Bernaung

class student {
   let name: String
   var section: marks?
   init(name: String) {
      self.name = name
   }
   deinit { print("\(name)") }
}

class marks {
   let marks: Int
   unowned let stname: student
   
   init(marks: Int, stname: student) {
      self.marks = marks
      self.stname = stname
   }
   deinit { print("Marks Obtained by the student is \(marks)") }
}

var module: student?
module = student(name: "ARC")
module!.section = marks(marks: 98, stname: module!)
module = nil

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

ARC
Marks Obtained by the student is 98

Siklus Referensi Kuat untuk Penutupan

Ketika kita menetapkan closure ke properti instance kelas dan ke badan closure untuk menangkap instance tertentu, siklus referensi yang kuat dapat terjadi. Referensi kuat ke closure didefinisikan oleh 'self.someProperty' atau 'self.someMethod ()'. Siklus referensi yang kuat digunakan sebagai tipe referensi untuk closure.

class HTMLElement {
   let samplename: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      if let text = self.text {
         return "<\(self.samplename)>\(text)</\(self.samplename)>"
      } else {
         return "<\(self.samplename) />"
      }
   }
   init(samplename: String, text: String? = nil) {
      self.samplename = samplename
      self.text = text
   }
   deinit {
      print("\(samplename) is being deinitialized")
   }
}

var paragraph: HTMLElement? = HTMLElement(samplename: "p", text: "Welcome to Closure SRC")
print(paragraph!.asHTML())

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

<p>Welcome to Closure SRC</p>

Referensi Lemah dan Tidak Terkenal

Ketika closure dan instance merujuk satu sama lain, pengguna dapat mendefinisikan tangkapan dalam closure sebagai referensi yang tidak dimiliki. Maka itu tidak akan memungkinkan pengguna untuk membatalkan alokasi instance pada saat yang bersamaan. Ketika instance terkadang mengembalikan nilai 'nil', tentukan penutupan dengan instance yang lemah.

class HTMLElement {
   let module: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      [unowned self] in
      if let text = self.text {
         return "<\(self.module)>\(text)</\(self.module)>"
      } else {
         return "<\(self.module) />"
      }
   }
   init(module: String, text: String? = nil) {
      self.module = module
      self.text = text
   }
   deinit {
      print("\(module) the deinit()")
   }
}

var paragraph: HTMLElement? = HTMLElement(module: "Inside", text: "ARC Weak References")
print(paragraph!.asHTML())
paragraph = nil

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

<Inside>ARC Weak References</Inside>
Inside the deinit()

Post a Comment for "Belajar Swift : Contoh Program ARC Overview di Swift dan Fungsinya"