自动引用计数的工作机制
// 下面的例子展示了自动引用计数的工作机制
class Person {
let name: String
init(name: String) {
self.name = name
print("\(name) is being initialized")
}
deinit {
print("\(name) is being deinitialized")
}
}
// 定义了三个 Peroson? 类型的变量，用来按照代码中的顺序，为新的 Person 实例设置多个引用。由于可选类型的变量会被自动初始化为一个 nil 值，目前还不会引用到 Person 类的实例
var reference1: Person?
var reference2: Person?
var reference3: Person?
// Person 实例并且将它赋值给三个变量中的一个：
reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized"
// 将同一个 Person 实例分配给了两个变量，则该实例又会多出两个强引用：
reference2 = reference1
reference3 = reference1
// 你通过给其中两个变量赋值 nil 的方式断开两个强引用（包括最先的那个强引用），只留下一个强引用， Person 实例不会被销毁：
reference1 = nil
reference2 = nil
// 在你清楚地表明不再使用这个 Person 实例时，直到第三个也就是最后一个强引用被断开时 ARC 会销毁它。
reference3 = nil
// prints "John Appleseed is being deinitialized"
循环强引用
// 解决循环强引用问题，可以通过定义类之间的关系为弱引用( weak )或无主引用( unowned )来代替强引用
// 房子可以没人，人也可以没房子（即都可以为nil）
class Person {
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: Person?
deinit { print("Apartment \(unit) is being deinitialized") }
}
var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john
// 即使都nil 也不会走deinit方法～
john = nil
unit4A = nil
解决实例之间的循环强引用
// Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（ weak reference ）和无主引用（ unowned reference )。
弱引用 (在前面加上关键字 weak)
// 弱引用:弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 释放被引用的实例
// 所以说实例被释放了弱引用仍旧引用着这个实例也是有可能的
// 由于弱引用需要允许它们的值为 nil ，它们一定得是可选类型。
// 人可以nil,但是信用卡必须绑定一个人（即 一个可nil，一个不可nil）
class Person {
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: Person?
deinit { print("Apartment \(unit) is being deinitialized") }
}
var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john
john = nil
// prints "John Appleseed is being reinitialized"
// 由于再也没有强引用到 Person 它被释放掉了并且 tenant 属性被设置为 nil ：
unit4A = nil
// prints "Apartment 4A is being deinitialized"
无主引用 (在前面加上关键字 unowned )
// 和弱引用类似，无主引用不会牢牢保持住引用的实例。
// 但是不像弱引用，总之，无主引用假定是永远有值的。
// 因此，无主引用总是被定义为非可选类型。
// 由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以直接访问。不过 ARC 无法在实例被释放后将无主引用设为 nil ，因为非可选类型的变量不允许被赋值为 nil 。
// 如果你试图在实例的被释放后访问无主引用，那么你将触发运行时错误。只有在你确保引用会一直引用实例的时候才使用无主引用。
// 还要注意的是，如果你试图访问引用的实例已经被释放了的无主引用，Swift 会确保程序直接崩溃。你不会因此而遭遇无法预期的行为。所以你应当避免这样的事情发生。(空指针异常)
class Customer {
let name: String
var card: CreditCard?
init(name: String) {
self.name = name
}
deinit { print("\(name) is being deinitialized") }
}
class CreditCard {
let number: UInt64
unowned let customer: Customer
init(number: UInt64, customer: Customer) {
self.number = number
self.customer = customer
}
deinit { print("Card #\(number) is being deinitialized") }
}
var john: Customer?
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456， customer: john!)
// 因为不再有 Customer 的强引用，该实例被释放了。其后，再也没有指向 CreditCard 实例的强引用，该实例也随之被释放了
john = nil
// prints "John Appleseed is being deinitialized"
// prints "Card #1234567890123456 is being reinitialized"
无主引用和隐式展开的可选属性
//上面弱引用和无主引用例子涵盖了两种常用的需要打破循环强引用的场景:
- Person 和 Apartment 的例子展示了两个属性的值都允许为 nil ，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
- Customer 和 CreditCard 的例子展示了一个属性的值允许为 nil ，而另一个属性的值不允许为 nil ，这也可能导致循环强引用。这种场景最好使用无主引用来解决。
- 还有第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为 nil 。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式展开的可选属性。
// Country 和 City ，每个类将另外一个类的实例保存为属性。在这个数据模型中，每个国家必须有首都，每个城市必须属于一个国家。为了实现这种关系， Country 类拥有一个 capitalCity 属性，而 City 类有一个 country 属性：（都不可nil）
class Country {
let name: String
var capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
}
class City {
let name: String
unowned let country: Country
init(name: String, country: Country) {
self.name = name
self.country = country
}
}
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// prints "Canada's capital city is called Ottawa"
闭包的循环强引用(block的循环饮用)
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> 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())
// prints "<h1>some default text</h1>"
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// prints"hello, world"
// 解决 这句话？ [unowned self, weak delegate = self.delegate!] 放在闭包的参数返回值之前
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// prints"hello, world"
lazy var someClosure: Void -> String = {
[unowned self, weak delegate = self.delegate!] in
// closure body goes here
}
// 解决
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: Void -> 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())
// prints "<p>hello, world</p>"
paragraph = nil
// prints "p is being deinitialized"
