写时复制

在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
}