本章包含内容：
- 深浅拷贝
- 字符串的拷贝
- 集合类的拷贝
- 隐式强引用-集合，timer、元组
- 闭包属性引起的循环强引用
- 解决闭包属性引起的循环强引用
一、深浅拷贝
直接给出结论：
- 值类型的赋值属于深拷贝（重新申请一份内存，把原内存上的内容拷贝一份到新的内存中）
- 引用类型的赋值属于浅拷贝（指向同一份内存）
从上面给出的结论，我们可以通过以下代码验证：
//结构体、值类型
struct Deep {
var copy: Int = 0
}
//类、引用类型
class Shallow {
var copy: Int = 0
}
var d0 = Deep()
var d1 = d0
d1.copy = 10
//此时时深拷贝，d0和d1修改的是不同的内存地址
print(d0.copy)//输出 0
print(d1.copy)//输出 10
var s0 = Shallow()
var s1 = s0
//此时时浅拷贝，s0和s1修改的是同一份内存地址
s1.copy = 9
print(s0.copy)//输出9
print(s1.copy)//输出9
二、字符串的拷贝
直接给出结论：
- String类型的赋值属于深拷贝（struct类型）
- NSMutableString类型的赋值属于浅拷贝（class类型）
从上面给出的结论，我们可以通过以下代码验证：
var swiftStr: String = "Hello"
var swiftStr1 = swiftStr
swiftStr1 += " world"
print(swiftStr) //输出：Hello
print(swiftStr1)//输出：Hello world
var ocStr = NSMutableString(string: "Hello")
var ocStr1 = ocStr
ocStr1.insert(" world", at: ocStr.length)
print(ocStr) //输出：Hello world
print(ocStr1)//输出：Hello world
三、集合类的拷贝
集合的拷贝如下：
//struct类型
var array:Array<Int> = [1,2,3]
var array1 = array
array1 += [4,5,6]
//深拷贝
print(array) //输出：[1, 2, 3]
print(array1)//输出：[1, 2, 3, 4, 5, 6]
//struct类型
var dict:Dictionary<Int,String> = [1:"a",2:"b"]
var dict1 = dict
dict[3] = "c"
//深拷贝
print(dict) //输出：[2: "b", 3: "c", 1: "a"]
print(dict1)//输出：[2: "b", 1: "a"]
//class类型
var ocArray = NSMutableArray(array:[1,2,3])
var ocArray1 = ocArray
ocArray1.add(5)
//浅拷贝
print(ocArray)
/*
输出：
(
1,
2,
3,
5
)
*/
print(ocArray1)
/*
输出：
(
1,
2,
3,
5
)
*/
数组的拷贝过程：
- （1）根据被拷贝数组的大小来创建一个新的数组对象，新的容量跟原始数组大小相同
- （2）将原始数组中的每一个元素一次拷贝到新的数组对象中
以上拷贝过程，可以通过以下代码验证：
//结构体、值类型
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 sharray = [sh0,sh1]
//深拷贝
var dearray1 = dearray
var sharray1 = sharray
//当将数组中的某个元素替换，或者改变了数组的大小，不会影响另外一个数组。
/* 深拷贝
dearray1.removeLast()
print(dearray1.count)//输出：1
print(dearray.count)//输出：2
*/
//深拷贝
dearray1[0] = Deep(copy: 3)
print(dearray1[0].copy) //输出3
print(dearray[0].copy) //输出1
//此时是浅拷贝
sharray[0].copy = 99
print(sharray[0].copy) //输出:99
print(sharray1[0].copy)//输出:99
四、隐式强引用
以下是显示强引用
class Student {
var name: String
init(name: String) {
self.name = name
}
func show() {
print("name = \(name)")
}
deinit {
print("\(name) deinit")
}
}
//此时，stu0和stu1都引用了同一个对象
var stu0: Student? = Student(name: "Tom") //引用计数+1
var stu1 = stu0 //引用计数+1
stu0 = nil //用用计数-1
stu1 = nil //用用计数-1
与之对应的，以下是隐式强引用：
class Student {
var name: String
init(name: String) {
self.name = name
}
func show() {
print("name = \(name)")
}
deinit {
print("\(name) deinit")
}
}
//此时，stu0和stu1都引用了同一个对象
/*
var stu0: Student? = Student(name: "Tom") //引用计数+1
var stu1 = stu0 //引用计数+1
stu0 = nil //用用计数-1
stu1 = nil //用用计数-1
*/
//放到外面，此时构造出的两个对象，构造完成即销毁
/*
Student(name: "zhangsan") //输出：Tom deinit
Student(name: "lisi") //输出：zhangsan deinit
*/
//将对象放到数组内，因数组内的元素是引用类型，那么数组会强引用该对象
var stuarray:[Student] = [Student(name: "zhangsan"), Student(name: "lisi")]
stuarray[0].name = "zhangsanfeng"
//（1）当某个对象不在属于数组时，该对象的引用对象会减1
//（2）数组本身被销毁的时候，它包含的所有对象不再属于它，因此如果对象是引用数据类型，它的计数将会减1
stuarray.remove(at: 0)//此时zhangsanfeng对象将被释放
五、闭包属性引起的循环强引用
class CycleRef {
//闭包是引用类型
lazy var closure:()->Void = {
print("closure!")
}
deinit {
print("deinit")
}
}
var cr:CycleRef? = CycleRef()
cr!.closure()//在这时候才初始化closure:()，输出：closure!
cr = nil //输出：deinit
将以上代码修改如下将引起循环强引用：
class CycleRef {
var a: Int = 9
//闭包是引用类型
lazy var closure:()->Void = {
print("a = \(self.a)")
}
deinit {
print("deinit")
}
}
var cr:CycleRef? = CycleRef() //引用计数+1
cr!.closure()//在这时候才初始化closure:()，输出：closure! 引用计数+1
cr = nil //没有输出deinit，代表此时对象没有被释放，内存泄漏了
六、解决闭包属性引起的循环强引用
[unowned self] in 解决闭包属性引起的循环强引用：
class CycleRef {
var a: Int = 9
//如果闭包属性中没有直接或者间接访问self,就不会产生循环强引用
//闭包是引用类型
lazy var closure:()->Void = {
//默认闭包会对它访问的对象执行强引用
[unowned self] in //添加这句代码
print("a = \(self.a)")
}
deinit {
print("deinit")
}
}
var cr:CycleRef? = CycleRef() //引用计数+1
cr!.closure()//在这时候才初始化closure:()，输出：closure! 引用计数+1
cr = nil //因为在闭包中添加了[unowned self] in这句代码，此时输出：deinit，代表此时对象被释放
[weak self] in 解决闭包属性引起的循环强引用：
class CycleRef {
var a: Int = 9
//如果闭包属性中没有直接或者间接访问self,就不会产生循环强引用
//闭包是引用类型
lazy var closure:()->Void = {
//默认闭包会对它访问的对象执行强引用
[weak self] in //添加这句代码
print("a = \(self!.a)")
}
deinit {
print("deinit")
}
}
var cr:CycleRef? = CycleRef() //引用计数+1
cr!.closure()//在这时候才初始化closure:()，输出：closure! 引用计数+1
cr = nil //因为在闭包中添加了[weak self] in这句代码，此时输出：deinit，代表此时对象被释放
因为weak一般修饰的是可选类型，所以我们在很多时候会使用** [unowned self] in**
