Swift中的可选链与内存管理(干货系列)

干货之前：补充一下可选链(optional chain)

class A {
    var p: B?

}

class B
{
    var p: C?
}

class C {
    func cm() -> String {
        print("cm")
        return "abc"
    }
}

let insa = A()
let insb = B()
let insc = C()
insa.p = insb
//insa.p = nil
insb.p = insc

let r = insa.p?.p?.cm()

解析：此处定义了A,B,C三个类，使其依次关联，最后通过类A实例的属性拿到B实例，依次拿到C实例再调用C的方法。

注意：1，中间任何一个地方为nil，不报错，但导致整个结果为nil。

2，如果没有一个地方为nil，整个表达式才正常执行。

内存管理

swift中的或者java，c#语言的内存管理，指的就是引用类型对象的管理，也就是对“堆（heap）”里面的对象的管理。

这三种语言中，值类型不需要进行内存管理，值类型是放在栈里的，程序会自动管理，不需要特别的机制。

swift中的内存管理技术，叫做arc，自动引用计数（Auto Reference Count） 当对对象的引用计数为0时，立即销毁对象

这种管理一般会产生两种错误可能

1.空引用

2.内存泄露（leak） 某个时候，某些对象分配了内存，但因为某些原因，导致程序结束时，此对象所占的内存没有被回收

我们可以控制的引用计数的数量 增加的方法 1.声明变量，指向某个对象（直接new或者把别的变量的值赋值给你 ）

减少的方法

1.f = nil(表示不指向任何东西）

2.变量一般会运行在函数中，变量本身是存放在栈中的 所以函数结束时，此变量消失

关于循环引用swift提供了两种方法来解决，

一种是weak（弱），一种是unowned（未拥有）

1.weak 可以修饰在可为空（?,!）的属性上

2.unowned只能修饰在非可为空的属性上。

循环引用案例

class A {
    var p: B?
    init() {
        print("a********************")
    }
    deinit {
        print("a--------------------")
    }
}

class B{
    var p: A?
    init() {
        print("b********************")
    }
    deinit {
        print("b--------------------")
    }

}
var f1:A? = A()
var f2:B? = B()
//使用这两个类时，可以从控制台看到这两个类已经初始化完毕
//通过f1f2两个对象的属性将这两个类相互关联
f1?.p = f2
f2?.p = f1
//此时再将这两个对象赋值为nil
//f1 = nil
//f2 = nil
//但此时并没有调用类的析构函数
//原因：f1f2这两个对象的属性相互引用了这两个对象
f1?.p = nil
f2?.p = nil
f1 = nil
f2 = nil

解析：1，此处现将f1f2两对象的属性赋值为nil再将f1f2赋值为nil即代表A,B这两个类完全没有引用，此时才会调用析构函数，回收内存。

2，以上这种循环引用的问题，对象并没有真正清除常常会导致内存泄漏(leak)

解决方法一：weak

class C {
    var p: D?
    init() {
        print("c********************")
    }
    deinit {
        print("c--------------------")
    }
}

class D{
    weak var p: C?
    init() {
        print("d********************")
    }
    deinit {
        print("d--------------------")
    }
    
}
var f3:C? = C()
var f4:D? = D()
f3 = nil
f4 = nil

此时发现在任何一个循环引用的属性上加上weak关键字，即可解决上述问题

注意：weak 可以修饰在可为空（?,!）的属性上

解决方式二：unowned

class E {
    var p: F?
    init() {
        print("e********************")
    }
    deinit {
        print("e--------------------")
    }
}

class F{
    unowned var p: E
    init(a:E) {
        p = a
        print("f********************")
    }
    deinit {
        print("f--------------------")
    }
    
}
var f5:E? = E()
var f6:F? = F(a:f5!)
f5 = nil
f6 = nil

注意：unowned只能修饰在非可为空的属性上。