《swift2.0 官方教程中文版》 第2章-16自动引用计数

import Foundation

/*自动引用计数的工作机制********************************************/

//当你每次创建一个类的新的实例的时候,ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型 信息,以及这个实例所有相关属性的值。

//为了确保使用中的实例不会被销毁,ARC 会跟踪和计算每一个实例正在被多少属性,常量和变量所引用。哪怕实 例的引用数为1,ARC都不会销毁这个实例。

//为了使上述成为可能,无论你将实例赋值给属性、常量或变量,它们都会创建此实例的强引用。之所以称之为“强”引用,是因为它会将实例牢牢的保持住,只要强引用还在,实例是不允许被销毁的。

/*自动引用计数实践********************************************/

class Person {

    let name: String

    init(name: String) {

        self.name = name

        print("\(name) is being initialized")

    }

    deinit{

        print("\(name) is being deinitialized")

    }

}

//接下来的代码片段定义了三个类型为 Person? 的变量,用来按照代码片段中的顺序,为新的 Person 实例建立 多个引用。由于这些变量是被定义为可选类型( Person? ,而不是 Person ),它们的值会被自动初始化为 ni l ,目前还不会引用到 Person 类的实例。

var reference1: Person?

var reference2: Person?

var reference3: Person?

reference1 = Person(name: "John Appleseed")

// prints "John Appleseed is being initialized”

reference2 = reference1

reference3 = reference1

//现在这一个 Person 实例已经有三个强引用了。

//如果你通过给其中两个变量赋值 nil 的方式断开两个强引用(包括最先的那个强引用),只留下一个强引用,Person 实例不会被销毁:

reference1 = nil

reference2 = nil

//在你清楚地表明不再使用这个 Person 实例时,即第三个也就是最后一个强引用被断开时,ARC 会销毁它。

reference3 = nil

// prints "John Appleseed is being deinitialized"

/*类实例之间的循环强引用********************************************/

class Person1 {

    let name: String

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

    var apartment: Apartment?

    deinit{ print("\(name) is being deinitialized") }

}

class Apartment {

    let number: Int

    init(number: Int) { self.number = number }

    var tenant: Person1?

    deinit { print("Apartment #\(number) is being deinitialized") }

}

var john: Person1?

var number73: Apartment?

john = Person1(name: "John Appleseed")

number73 = Apartment(number: 73)

//现在你能够将这两个实例关联在一起,这样人就能有公寓住了,而公寓也有了房客。注意感叹号是用来展开和访 问可选变量 john 和 number73 中的实例,这样实例的属性才能被赋值:

john!.apartment = number73

number73!.tenant = john

john = nil

number73 = nil

//Person2和 Apartment  实例之间的强引用关系保留了下来并且不会被断开。

/*解决实例之间的循环强引用********************************************/

//Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题:弱引用(weak reference)和无主引用(unowned reference)。

//对于生命周期中会变为 nil 的实例使用弱引用。相反地,对于初始化赋值后再也不会被赋值为 nil 的实例,使用无 主引用。

//弱引用

//弱引用不会对其引用的实例保持强引用,因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时,在前面加上 weak 关键字表明这是一个弱引用。

class Person3 {

    let name: String

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

    var apartment: Apartment3?

    deinit { print("\(name) is being deinitialized") }

}

class Apartment3 {

    let number: Int

    init(number: Int) { self.number = number }

    weak var tenant: Person3?

    deinit { print("Apartment #\(number) is being deinitialized") }

}

var john3: Person3?

var number733: Apartment3?

john3 = Person3(name: "John Appleseed")

number733 = Apartment3(number: 733)

john3!.apartment = number733

number733!.tenant = john3

//Person 实例依然保持对 Apartment 实例的强引用,但是 Apartment 实例只是对 Person 实例的弱引用。这意 味着当你断开 john 变量所保持的强引用时,再也没有指向 Person 实例的强引用了

john3 = nil

// prints "John Appleseed is being deinitialized"

number733 = nil

// prints "Apartment #733 is being deinitialized"

//无主引用

//和弱引用类似,无主引用不会牢牢保持住引用的实例。和弱引用不同的是,无主引用是永远有值的。因此,无主 引用总是被定义为非可选类型(non-optional type)。你可以在声明属性或者变量时,在前面加上关键字 unow ned 表示这是一个无主引用。

//注意: 如果你试图在实例被销毁后,访问该实例的无主引用,会触发运行时错误。使用无主引用,你必须确保引用始终 指向一个未销毁的实例。

//还需要注意的是如果你试图访问实例已经被销毁的无主引用,Swift确保程序会直接崩溃,而不会发生无法预期 的行为。所以你应当避免这样的事情发生。

//下面的例子定义了两个类, Customer 和 CreditCard ,模拟了银行客户和客户的信用卡。这两个类中,每一个 都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。

//在这个数据模型中,一个客户可能有或者没有信用卡,但是一张信用卡总是关联着一个客户。为了表示这种关系, Customer 类有一个可选类型的 card 属性,但是 CreditCard 类有一个非可选类型的 customer 属性。

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")}

}

//CreditCard 类的 number 属性被定义为 UInt64 类型而不是 Int 类型,以确保 number 属性的存储量在 32位和64位系统上都能足够容纳16位的卡号。

var jake: Customer?

jake = Customer(name: "Jake Appleseed")

jake!.card = CreditCard(number: 1234_5678_9012_3456, customer: jake!)

jake = nil

// prints "John Appleseed is being deinitialized"

// prints "Card #1234567890123456 is being deinitialized"

//下面的例子定义了两个类, Country 和 City ,每个类将另外一个类的实例保存为属性。在这个模型中,每个国 家必须有首都,每个城市必须属于一个国家。为了实现这种关系, Country 类拥有一个 capitalCity 属性,而 Cit y 类有一个 country 属性:

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

    }

}

//将 Country 的 capitalCity 属性声明为隐 式解析可选类型的属性。这表示像其他可选类型一样, capitalCity 属性的默认值为 nil ,但是不需要展开它的值 就能访问它

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"

/*闭包引起的循环强引用********************************************/

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")

    }

}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")

print(paragraph!.asHTML())

// prints"hello, world"

paragraph = nil

/*解决闭包引起的循环强引用********************************************/

//在定义闭包时同时定义捕获列表作为闭包的一部分,通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样,声明每个捕获的引用为弱引用或无主引用,而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

//注意:

//Swift 有如下要求:只要在闭包内使用 self 的成员,就要用 self.someProperty 或者 self.someMethod (而不只是 someProperty 或 someMethod )。这提醒你可能会一不小心就捕获了 self 。

class HTMLElement2 {

    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")

    }

}

//这里,捕获列表 是 [unowned self] ,表示“用无主引用而不是强引用来捕获 self ”。

var paragraph2: HTMLElement2? = HTMLElement2(name: "p", text: "hello, world")

print(paragraph2!.asHTML())

// prints "<p>hello, world</p>"

//这一次,闭包以无主引用的形式捕获 self ,并不会持有 HTMLElement 实例的强引用。如果将 paragraph 赋值 为 nil , HTMLElement 实例将会被销毁,并能看到它的析构函数打印出的消息。

paragraph2 = nil

// prints "p is being deinitialized"