本章包含內容：
- 深淺拷貝
- 字符串的拷貝
- 集合類的拷貝
- 隱式強引用-集合，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**
