Swift中值类型、引用类型以及写时复制

大家都知道swift是有值类型和应用类型
1.值类型(Value Type)：即每个实例保持一份数据拷贝。
2.引用类型(Reference Type)：即所有实例共享一份数据拷贝。
区别：结构体和class 一个是指类型一个是引用用类型 class可以继承 结构体不行

Swift有三种声明类型的方式：class，struct和enum。它们可以分为值类型（struct和enum）和引用类型（class）。它们在内存中的存储方式不同决定它们之间的区别：

值类型是这样一种类型，当它被赋值给一个变量、常量或者被传递给一个函数的时候，其值会被拷⻉。
实际上，Swift 中所有的基本类型:整数 (integer)、浮点数(floating-point number)、布尔值(boolean)、字符串串(string)、数组 (array)和字典(dictionary)，都是值类型，其底层是使用结构体实现的。Swift 中所有的结构体和枚举类型都是值类型。这意味着它们的实例例，以及实例例中所包含的任何 值类型的属性，在代码中传递的时候都会被复制。
与值类型不同，引⽤类型在被赋予到一个变量量、常量或者被传递到一个函数时，其值不会被拷贝。因此，使用的是已存在实例的引⽤，而不是其拷贝。

一、验证值类型

import UIKit

struct Point {
    var x: Double
    var y: Double
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let point1 = Point(x: 3, y: 5)
        var point2 = point1
        
        print(point1)           // Point(x: 3.0, y: 5.0)
        print(point2)           // Point(x: 3.0, y: 5.0)
        
        point2.x = 5
        
        print(point1)           // Point(x: 3.0, y: 5.0)
        print(point2)           // Point(x: 3.0, y: 5.0)
        
    }
}

//打印point1 不随着 point2 而变化 。说明他们内存独立
Point(x: 3.0, y: 5.0)
Point(x: 3.0, y: 5.0)
Point(x: 5.0, y: 5.0)

二、验证引用类型：

import UIKit

class Point {
    var x: Double = 0.0
    var y: Double = 0.0
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let point1 = Point()
        point1.x = 3.0
        point1.y = 5.0
        let point2 = point1
        
        print(point1)
        print(point2)
        
        point2.x = 5
        
        print(point1.x , point1.y)
        print(point2.x , point2.y)
    }
}

//打印point1 随着 point2 而变化 。说明他们公用一块内存
5.0 5.0
5.0 5.0

三、写时复制

我们发现 Array 这个结构体并没有任何 copy 相关的方法，那我们如何做到生成多个完全一致却又互不干扰的随机数组呢？查了资料发现，Swift 中 值类型 有“写时复制（Copy-On-Write）”的特性。

写时复制可以理解为，在其中一个对象没有作出修改时，两个对象共享一个地址，只有当其中一个对象发生改变之前是会同步复制生成一个新的对象。

验证写时复制
首先，让我们看下面的例子我们更容易理解，我们创建了数组 array1，然后将 array1 赋值给 array2，再给 array2 数组添加多一个元素，我们通过查看其地址变化来确定是否进行了拷贝行为。

let array1 = [1, 2, 3, 4]
var array2 = array1
// 断点1
array2.append(2) 
// 断点2
print("hello world")

断点1位置，使用 lldb 命令 fr v -R [object] 来查看对象内存结构。打印出 array1，array2 内存结构如下，我们可以看到 array1 和 array2 内存地址都是 0x0000000101a1a590，说明 array1 和 array2 此时是共享同一个实例

(lldb) fr v -R array1
(Swift.Array) array1 = {
  _buffer = {
    _storage = {
      rawValue = 0x0000000101a1a590 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 4
              }
              _capacityAndFlags = {
                _value = 8
              }
            }
          }
        }
      }
    }
  }
}
(lldb) fr v -R array2
(Swift.Array) array2 = {
  _buffer = {
    _storage = {
      rawValue = 0x0000000101a1a590 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 4
              }
              _capacityAndFlags = {
                _value = 8
              }
            }
          }
        }
      }
    }
  }
}

断点2位置，此时 array2 添加了新元素，打印 array2，内存结构如下，我们可以看到 array2 内存地址已经变成了0x0000000101a1a5d0，说明此时它们不再共享同一个实例，array2 对应的值进行了拷贝行为

(lldb) fr v -R array2
(Swift.Array) array2 = {
  _buffer = {
    _storage = {
      rawValue = 0x0000000101a1a5d0 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 5
              }
              _capacityAndFlags = {
                _value = 16
              }
            }
          }
        }
      }
    }
  }
}

由此可见，array2 未做修改时，array1 和 array2 是共享同一个实例。