Swift-内存管理

//内存管理/自动引用计数/弱引用/非持有引用

 

//引用计数：每个对象都有一个引用计数，用来记录有多少人（对象或变量）需要该对象活着

//当引用计数>0的时候，该对象会保留在内存中

//当引用计数=0的时候，该对象会立刻从内存中销毁

 

//自动引用计数不等于垃圾回收机制，垃圾回收机制是内存使用特别大/紧缺时，会检查各种结构（比如堆栈）、对象，在需要清理时给予清理

 

//弱引用不会增加引用计数: weak var xxx

//弱引用一定是可能值类型

 

//对可能值进行绑定会产生一个强引用,如下

//if letperson = apt.person {

//   person.dingDong()

//}

//person就是一个指向apt.person的强引用，该强引用在if{}结束后销毁

 

//可能值链也会产生强引用，只在所在行生效，不会保存到下一行，如下

//apt.person?.dingDong

//apt.person?.greet()

 

//强引用：一般的指向对象的变量都是强引用，比如：局部变量，对象属性

//弱引用或非持有引用：当引用需要反向指回时，如果还使用强引用会产生引用回路，从而内存泄露。

 

//引用计数只引用在类的实例。结构体和枚举是值类型，不是引用类型，不是以引用的方式来存储和传递的。

 

//=============================================

//      Person&Apartment的例子

//是两个属性都可以是nil，这种场景适合使用弱引用

//=============================================

 

class Person {

    let name: String

    weak varapartment : Apartment?

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

   deinit { println("\(name) is beingdeinitialized") }

}

 

class Apartment {

    let number: Int

    var name = "Qs"

    weak var tenant: Person? = nil

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

   deinit { println("Apartment #\(number) is beingdeinitialized") }

}

 

var john:Person?

var number73:Apartment?

 

john =Person(name:"John Qiu")

number73 =Apartment(number:73)

 

john?.apartment =number73

number73?.tenant =john

let name1 =john!.apartment!.name

let name2 =john?.apartment?.name

 

number73?.tenant =nil

number73?.tenant

 

//无主引用：ZZ称非持有引用，JKXY称无主引用

//无主引用始终有值，不会为nil，只能定义为非可选类型，可以直接使用，不用解析(!)

//同生命线的关系

//===========================================

//   Customer&CreditCard的例子

//是一个属性是nil，另外一个属性不允许是nil

//这种场景适合使用无主引用

//===========================================

class Customer {

    let name: String

    var card: CreditCard?

    init(name: String){

       self.name= name

       println("\(name) is beinginitialized")

    }

   deinit { println("\(name) is beingdeinitialized") }

}

 

class CreditCard {

    let number: Int

    unowned letcustomer: Customer

    init(number: Int,customer: Customer) {

       self.number= number

       self.customer= customer

       println("Card #\(self.number) is beinginitialized")

    }

   deinit{ println("Card #\(self.number) is beingdeinitialized") }

}

 

 

var Tom:Customer?

var ICard:CreditCard

Tom =Customer(name:"Tom Qiu")

Tom!.card =CreditCard(number:9558801,customer:Tom!)// "Tom!"用于作为实参的初始化参数必须要是确定值，不能是可能值，否则报错

ICard =CreditCard(number:9558802, customer:Tom!)

Tom?.card =ICard

Tom?.card

 

 

var Jack:Customer?

var ICard1:CreditCard?

Jack =Customer(name:"Jack Qiu") //Jack Qiu is being initialized

ICard1 =CreditCard(number:9558803, customer:Jack!) //Card #9558803 is being initialized

//"Jack!"实参的初始化参数必须要是确定值，不能是可能值，否则报错

Jack!.card =ICard1//Jack的card指向9558803

Jack?.card =CreditCard(number:9558804,customer:Jack!)// "Jack!"用于作为实参的初始化参数必须要是确定值，不能是可能值，否则报错

 

println(Jack!.card!.customer.name)//customer可以直接用，不用加!

Jack =nil   //Jack Qiu is being deinitialized Card #9558804 is beingdeinitialized

ICard1 =nil //Card #9558803 is being deinitialized

 

 

//无主引用以及隐式解析可选属性

//===========================================

//Country&City的例子

//是两个属性都必须有值，且初始化完成后不能为nil

//这种场景需要使用无主引用+隐式解析可选属性

//===========================================

class Country {

    let name: String

   let capitalCity:City!//隐式解析可选属性,如果这里用?，则后续调用需要强制解析

    init(name: String,capitalName: String) {

       self.name= name

       self.capitalCity =City(name: capitalName, country:self)//Country的实例完全初始化后才能将self送给City的初始化函数，因此

    }

    deinit {

       println("Countrydestroy")

    }

}

 

class City {

    let name: String

    unowned letcountry: Country

    init(name: String,country: Country) {

       self.name= name

       self.country= country

    }

    deinit {

       println("Citydestroy")

    }

}

 

var canada =Country(name:"Canada", capitalName:"Ottawa")

println("\(canada.name)'s capital city is called \(canada.capitalCity.name)")

//如果Country定义非隐式解析可选属性：let capitalCity: City? 则如下使用

//println("\(canada.name)'scapital city is called \(canada.capitalCity!.name)")

 

//********************捕获列表*********************

//************************************************

//类内方法嵌套闭包时，小心引用回路

//关键字：[unowned/weak self/instance]，

//格式：放在闭包参数前

//varsomeClosure: (Int, String) -> String = {

//   [unowned self](index: Int, stringToProcess: String) in

//   return " HAHA "

//}

//************************************************

 

class HTMLElement {

    let name: String

    let text: String?

   //下面用到捕获列表

    lazy varasHtml: () -> String = {

       [unowned self] in

       if lettext = self.text{

           return "\(self.name) +\(self.text!)"

       } else {

           return " \(self.name) "

       }

    }

    init(name: String,text: String? = nil){

       self.name= name

       self.text= text

    }

    deinit {

       println("\(name) destroy")

    }

}

 

 

var paragraph :HTMLElement?= HTMLElement(name:"HTName",text: "HTText")

println(paragraph!.asHtml())

paragraph =nil