Swift 基础学习(内存管理二)

/*
    Swift内存管理第二部分(高级)
(1)深浅拷贝
(2)字符串拷贝
(3)集合类的拷贝
(4)局部临时对象和全局对象
(5)类型属性的声明周期
(6)隐式强引用-集合类,timer/元组
(7)闭包属性引起的循环引用
(8)解决(7)的问题
*/

/*
(1)
*/
//结构体,值类型
struct Deep {
    var copy: Int = 0
}
//类,引用类型
class Shallow {
    var copy: Int = 0
}

//值类型的赋值操作是深拷贝
var d0 = Deep()
//深拷贝
//系统会分配一块内存与d1进行绑定,也就是说d1指向这块内存,这块内存的内容等于d0指向的内存的内容,二者只是内容相同而已,但分别指向不同的内存
var d1 = d0
d1.copy = 9
//值不一样就说明是两份不同的拷贝,打印结果为d0.copy为0,d1.copy为9
print(d0.copy)
print(d1.copy)

//引用类型的赋值操作是浅拷贝
//可能存在的问题:当多份引用同时指向一个对象时,如果对象提前释放,就会出现内存泄露
var s0 = Shallow()
//浅拷贝
var s1 = s0
s1.copy = 9
//打印结构都是9
print(s0.copy)
print(s1.copy)


/*
(2)字符串拷贝
*/
var swiftStr: String = "Hello"
var swiftStr1 = swiftStr
swiftStr1 += "World"
//swiftStr1的变化如果会引起swiftStr变化就是浅拷贝,结构发现是深拷贝;简单的方法我们可以直接看他们的类型
print(swiftStr)
print(swiftStr1)

//浅拷贝
var ocStr = NSMutableString(string: "Hello")
var ocStr1 = ocStr
ocStr1.insertString("World", atIndex: ocStr.length)
print(ocStr)
print(ocStr1)

/*
(3)集合类的拷贝
*/
//深拷贝
var array: Array<Int> = [1,2,3]
var array1 = array
array1 += [4,5,6]
print(array)
print(array1)

//深拷贝
var dict: Dictionary<Int, String> = [1:"a",2:"b"]
var dict1 = dict
dict1[3] = "c"
print(dict)
print(dict1)

//浅拷贝
var ocArray = NSMutableArray(array: [1,2,4])
var ocArray1 = ocArray
ocArray1.addObject(3)
print(ocArray)
print(ocArray1)

/*
(4)深入分析集合类的拷贝
//结构体,值类型
struct Deep {
var copy: Int = 0
}
//类,引用类型
class Shallow {
var copy: Int = 0
}
*/
var de0 = Deep()
var de1 = Deep()
//数组的元素都是值类型
var dearray = [de0,de1]

var sh0 = Shallow()
var sh1 = Shallow()
//数组的元素都是引用类型
var shaarray = [sh0, sh1]

//深拷贝
var dearray1 = dearray
var sharray1 = shaarray

/*
//当将数组中的某个元素替换,或者改变数组的大小,不会影响另外一个数组
dearray1.removeLast()
print(dearray1.count)
print(dearray.count)

dearray1[0] = Deep(copy: 3)
print(dearray1[0].copy)
print(dearray[0].copy)
*/

//(1)根据被拷贝数组的大小来创建一个新的数组对象,新的容量跟原始数组大小相同
//(2)将原始数组中的每一个元素依次拷贝到新的数组对象中
dearray1[0].copy = 88
print(dearray[0].copy)
print(dearray1[0].copy)

sharray1[0].copy = 99
print(shaarray[0].copy)
print(sharray1[0].copy)

/*
(5)隐式强引用
*/
class Student {
    var name: String
    init(name: String) {
        self.name = name
    }
    func show() {
        print("name = \(name)")
    }
    deinit {
        print("\(name) deinit!")
    }
}
//此时,stu0和stru1都引用了同一个对象
var stu0: Student? = Student(name: "Tom")
var stu1 = stu0
stu0 = nil
stu1 = nil

//Student(name: "zhangsan")
//Student(name: "lisi")
//对象加入到数组中,对象如果引用数据类型,那么数组会强引用该对象
//数组让该对象的引用计数加1
var stuarray: [Student]? = [Student(name: "zhangsan"), Student(name: "lisi")]
//(1)当某个对象不再属于数组时,该对象的引用计数会减1
//(2)数组本身被销毁的时候,它包含的所有对象不再属于它,因此如果对象是引用数据类型,它的计数将会减1
//stuarray.removeAtIndex(0)
stuarray = nil

/*
(6)局部和全局引用
*/
//1.作用域 2.生命周期
//let ref: Int = Int(5)

if true {
    var ref: Student = Student(name: "xiaocui")
}

//全局引用作用域:定义的位置开始到文件的结尾处
var gloabal_ref = Int(8)
gloabal_ref = 10

//生命周期: 跟当前程序的生命周期相同
func testFunc() {
    gloabal_ref = 10
}

/*
(7)闭包属性引起的循环引用
*/
class CycleRef {
    var a: Int = 9
    //如果闭包属性中没有直接或者间接访问self,就不会产生循环强引用
    lazy var closure:() ->Void = {
        //默认闭包会对它访问的对象执行强引用
//        [unowned self] in //解决方法
//        print("a=\(self.a)")

        //等同于
        [weak self] in
        print("a = \(self!.a)")
    }
    deinit {
        print("deinit")
    }
}
//两个对象,闭包对象,cr指向的对象
//前提:闭包或者函数是引用数据类型.
var cr: CycleRef? = CycleRef()//引用计数:+1
cr!.closure()//引用计数: +1或+2...
cr = nil // -1