23.自动引用计数 Automatic Reference Co

//: Playground - noun: a place where people can play

import UIKit

// # define: Swift采用自动引用计数ARC(Automatic Reference Counting)来追踪和管理 App 的内存.当实例不再需要时，ARC会自动释放类实例所占用的内存。
// 注意：引用计数只应用于类的实例。结构体和枚举是值类型，不是引用类型，没有通过引用存储和传递。

// # ARC的工作机制

// # ARC
class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized.")
    }
    deinit {
        print("\(name) is being deinitialized.")
    }
}
var reference1: Person? // 默认后面自带= nil
var reference2: Person?
var reference3: Person?
reference1 = Person(name: "John Appleseed")
reference2 = reference1
reference3 = reference1 // John Appleseed实例有了三个强引用
reference1 = nil
reference2 = nil // 目前实例不会deinit
reference3 = nil // 实例被销毁

// # 类实例之间的循环强引用
// 意外地产生循环强引用
/*
class NewPerson {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized...") }
}
class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: NewPerson?
    deinit { print("Apartment \(unit) is being deinitialized...") }
}
var john: NewPerson?
var unit4A: Apartment?
john = NewPerson(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john
john = nil
unit4A = nil // 此后john和unit4A都在但是无法被访问了，造成了内存泄露
*/
// 情况1:两个实例内都有可选项引用对方,其中一个加上weak.
class NewPerson {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized...") }
}
class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: NewPerson?
    deinit { print("Apartment \(unit) is being deinitialized...") }
}
var john: NewPerson?
var unit4A: Apartment?
john = NewPerson(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john
john = nil
unit4A = nil
// trick: 弱指针有时用来实现简单的缓存机制。
// 情况2:一个实例用可选项引用对方,另一个实例用非可选项引用对方.解决办法是:在可选项前加weak,或在非可选项前加上unowned
// 无主引用实例被释放后还使用该引用,会导致程序错误.
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    } // 类的初始化过程:先生成各个变量,如果有默认值就按默认值来生成,没有默认值就先不初始化该实例;然后调用init进一步处理(注意:如果let已经被默认值初始化了,init也不能对其赋值,如果没有,在init中也只能被初始化一次.var可以多次赋值.)
}
class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
}
// 注意:CreditCard 类的 number 属性定义为 UInt64 类型而不是 Int ，以确保 number 属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
var mary: Customer?
var someCard: CreditCard?
mary = Customer(name: "Mary Sue")
someCard = CreditCard(number: 1234_5678_9012_3456, customer: mary!)
mary!.card = someCard
someCard = nil
mary = nil
// 无主引用不安全操作
// 情况3:trick:当两个实例都是非可选项时:一个使用无主属性,另一个使用隐式展开可选属性
class Country {
    let name: String
    var capitalCity: City!
    init(name: String, capitalName: String) {
        self.name = name // 此步完成后,全部存储属性有了值，初始化第一阶段结束,实例诞生,可以调用self了。必须把capitalCity设为隐式展开可选项，要不然self不可用
        self.capitalCity = City(name: capitalName, country: self) // 这一步很神奇，把自己用来创建自己属性的一个实例，创建完成后实际上是改变了自己。
    }
    deinit {
        print("\(name)")
    }
}
class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
    deinit {
        print("\(name)")
    }
}
// 如果在初始化时就必须要有对方，这是做不到的，因为对方还没有初始化，所以最好在一个实例创建时同时创建另一个实例
var country: Country?
country = Country(name: "Canada", capitalName: "Ottawa")
country = nil

// # 闭包的循环强引用
/*
class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}
// 改变闭包属性
let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())
// 循环强引用
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML()) // 在self.name中引用了HTMLElemnt的一个实例
paragraph = nil // will not be destructed
*/

// # 解决闭包的循环强引用
// 定义捕获列表
// 在闭包和捕获的实例总是互相引用并且总是同时释放时，将闭包内的捕获定义为无主引用。
// 在被捕获的引用可能会变为 nil 时，定义一个弱引用的捕获。
class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: () -> String = {
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
paragraph = nil // will be destructed

// trick:如果值类型的属性有类，则值类型实例赋值后还是指向同一个类实例
class Car {
    var brandName: String
    init(ofBrandName name: String) {
        brandName = name
        print("Initializing a car of brand \(brandName)")
    }
    deinit {
        print("Deinitializing a car of brand \(brandName)")
    }
}
struct Human {
    var name: String
    var car: Car?
    init(ofName name: String) {
        self.name = name
    }
}
var human1 = Human(ofName: "Kevin")
human1.car = Car(ofBrandName: "BMW")
var human2 = human1
human2.car!.brandName
human1.car = nil
human2.car = nil