写时复制
在swift中，像Array、Dictionary、Set等集合类型都是通过写时复制（copy-on-write）技术实现的。
例如一个整形数组
let x = [1,2,3,4]
var y = x
创建新变量 y，把 x 赋值给 y 会发生复制，现在x和y都是独立的结构体。然后这些Array 结构体含有指向某个内存的引用。这个内存就是数组元素存储在堆上的位置。我们可以通过 swift Array 的
@inlinable public func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
来获取 Array 元素存储的地址指针，我们可以看出数组x和y存储地址和元素确实都是相同的
let xPoints1 = x.withUnsafeBufferPointer{$0}
let yPoints1 = y.withUnsafeBufferPointer{$0}
print(xPoints1, x) // UnsafeBufferPointer(start: 0x000060000143b1e0, count: 4) [1, 2, 3, 4]
print(yPoints1, y) // UnsafeBufferPointer(start: 0x000060000143b1e0, count: 4) [1, 2, 3, 4]
然后我们对数组 y 进行操作：
let xPoints2 = x.withUnsafeBufferPointer{$0}
let yPoints2 = y.withUnsafeBufferPointer{$0}
y.append(5)
let xPoints2 = x.withUnsafeBufferPointer{$0}
let yPoints2 = y.withUnsafeBufferPointer{$0}
print(xPoints2, x) // UnsafeBufferPointer(start: 0x000060000143b1e0, count: 4) [1, 2, 3, 4]
print(yPoints2, y) // UnsafeBufferPointer(start: 0x0000600002516a80, count: 5) [1, 2, 3, 4, 5]
通过以上代码可以看出，当y引用的存储要改变时，存储进行了复制。这就是所谓的"写时复制"。
但是作为一个结构体的作者，你不能免费获得这种特性，你需要自己进行实现。当结构类型内部含有一个或者多个可变引用，同时想要保持值语义，并且不必要的复制，为你的类型实现写时复制是有意义的。
接下来，我们用 NSMutableArray 作为内部引用类型来实现 swift 中的值类型的 Array 结构体。
写实复制（昂贵模式）
我们首先将 _array 标记为结构体的私有属性。我们不再直接变更 _array，而
是通过一个计算属性 _arrayForWriting 来访问它。这个计算属性总是会复制 _array 并将其返回：
struct MyArray {
fileprivate var _array: NSMutableArray
fileprivate var _arrayForWriting: NSMutableArray {
mutating get {
_array = _array.mutableCopy() as! NSMutableArray
return _array
}
}
init(_ array: NSMutableArray) {
self._array = array.mutableCopy() as! NSMutableArray
}
mutating func add(_ other: MyArray) {
_arrayForWriting.addObjects(from: other._array as Array)
}
mutating func append(_ any: Any) {
_arrayForWriting.add(any)
}
var description: String {
return (_array as Array).description
}
}
我们通过get方法操作时，每次均复制 _array，这个结构体具有值语义了。但这样的做法虽然有效，但是当我们多次改变同一个变量时，效率很低，因为每次操作，都会通过 get 方法去复制 _array得到 _arrayForWriting。比如如下操作：
var array = MyArray(NSArray(array: [1, 2, 3, 4]))
for index in 5...9 {
array.append(index)
}
每次 append 都会需要调用 get 方法去复制 _array 。如果我们能让 _array 在没有被共享之前，对它进行原地变更就高效了。
写时复制（高效方式）
上述问题说道 _array 没有被共享之前，那就是我们要在它是唯一引用的时候进行原地修改，如果有别的变量也在强引用它，那么我们就需要复制 _array 后去再修改它了。在 Swift 中，提供了 isKnownUniquelyReferenced 函数来检查引用的唯一性，没有其他强应用将返回 true。由于对于 Objective-C 的类，它会直 接返回 false，所以我们可以创建一个 Swift 类，来封装 Objective-C 对象到 Swift类中。
final class Box<T> {
var uniqueValue: T
init(_ value: T) {
self.uniqueValue = value
}
}
现在我们改造之前写的 MyArray
struct MyArray {
private var _data: Box<NSMutableArray>
private var _dataForWriting: NSMutableArray {
mutating get {
if !isKnownUniquelyReferenced(&_data) {
_data = Box(_data.uniqueValue.mutableCopy() as! NSMutableArray)
print("Making a copy")
}
return _data.uniqueValue
}
}
init(_ array: NSArray) {
self._data = Box(array.mutableCopy() as! NSMutableArray)
}
mutating func append(_ other: MyArray) {
_dataForWriting.addObjects(from: other._data.uniqueValue as Array)
}
mutating func append(_ any: Any) {
_dataForWriting.add(any)
}
var description: String {
return (_data.uniqueValue as Array).description
}
}
现在我们可以测试一下：
static func testMyArray() {
var x = MyArray(NSArray(array: [1, 2, 3, 4]))
// 原地操作
x.append(5)
var y = x
print(x.description, y.description) // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
y.append(6) // Making a copy
print(x.description, y.description) // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5, 6]
}
原地操作不会发生复制，而我们赋值给 y 后，对应进行操作，此时发生了复制。至此写时复制已经完成
对于有的书上说：Array 和 Dictionary下标取值值元素有不同，通过下标操作其实一样是会进行复制：
static func testTrap() {
let arrayForDict = MyArray(NSArray(array: [1, 2, 3, 4]))
var dict: [String: MyArray] = ["s": arrayForDict]
dict["s"]!.append(6) // Making a copy
let arrayForArray = MyArray(NSArray(array: [5, 6, 7, 8]))
var array = [arrayForArray]
array[0].append(9) // Making a copy
}
