内存安全性

了解内存访问冲突 

// A write access to the memory where one is stored.
var one = 1
 
// A read access from the memory where one is stored.
print("We're number \(one)!")

你可以想象一个类似的问题比如你是如何更新一张写在纸上的预算。更新预算是一个两步过程：首先你添加项目的名字和价格，然后你改变总价来显示当前列表中的变化。在更新的前后，你可以读取任何预算信息并且得到正确的结果，图例如下：

这种长时写入访问的一个后果就是你不能访问作为输入输出传递的原本变量，就算生效范围和访问控制可能会允许你这么做——任何对原变量的访问都会造成冲突，比如说：

var stepSize = 1
 
func increment(_ number: inout Int) {
    number += stepSize
}
 
increment(&stepSize)
// Error: conflicting accesses to stepSize

在上面的代码中， stepSize 是一个全局变量，它通常可以在 increment(_:) 中可以访问。总之， stepSize 的读取访问与 number 的写入访问重叠了。入下图所示， number 和 stepSize 引用的是同一内存地址。读取和写入访问引用同一内存并且重叠，产生了冲突。

一种解决这个冲突的办法是显式地做一个 stepSize 的拷贝：

// Make an explicit copy.
var copyOfStepSize = stepSize
increment(&copyOfStepSize)
 
// Update the original.
stepSize = copyOfStepSize
// stepSize is now 2
// stepSize is now 2

当你在调用 increment(_:) 之前给 stepSize 了一份之后，显然 copyOfStepSizeis 基于当前的步长增加了。读取访问在写入访问开始前结束，所以不会再有冲突。

输入输出形式参数的长时写入访问的另一个后果是传入一个单独的变量作为实际形式参数给同一个函数的多个输入输出形式参数产生冲突。比如：

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
var playerOneScore = 42
var playerTwoScore = 30
balance(&playerOneScore, &playerTwoScore)  // OK
balance(&playerOneScore, &playerOneScore)
// Error: Conflicting accesses to playerOneScore

上边 balance(_:_:) 修改它的两个形式参数将它们的总数进行平均分配。用 playerOneScore 和 playerTwoScore 作为实际参数不会产生冲突——一共有两个写入访问在同一时间重叠，但它们访问的是不同的内存地址。相反，传入 playerOneScore 作为两个形式参数的值则产生冲突，因为它尝试执行两个写入访问到同一个内存地址且是在同一时间执行。

在方法中对 self 的访问冲突

结构体中的异变方法可以在方法调用时对 self 进行写入访问。比如说想象一个每个玩家都有生命值的游戏，当玩家受伤时降低生命值，以及一个能量值，它在使用技能时降低。

struct Player {
    var name: String
    var health: Int
    var energy: Int
    
    static let maxHealth = 10
    mutating func restoreHealth() {
        health = Player.maxHealth
    }
}

在上面 restoreHealth() 方法中，对 self 的写入访问在方法一开始就启动然后结束于方法返回。在这种情况下，在 restoreHealth() 中没有其他代码可能会重叠访问 Player 实例中的属性。下面的 shareHealth(with:) 方法则接收另一个 Player 实例作为输入输出形式参数，为重叠访问创建了可能性：

extension Player {
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}
 
var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria)  // OK

在上面的例子中，调用 Oscar 玩家的 shareHealth(with:) 方法分享血条给 Maria 玩家不会造成冲突。在方法调用的过程中只有一个写入访问到 oscar 因为 oscar 是异变方法中 self 值，并且在同一时间内只有一个写入访问到 maria 因为 maria 是以输入输出形式参数传递的。如下面的图例所示，他们访问了内存中不同的地址。就算他们的写入访问是同时发生的，但不会冲突。

总之，如果你把 oscar 作为实际参数传递给 shareHealth(with:) ，就出现了冲突：

oscar.shareHealth(with: &oscar)
// Error: conflicting accesses to oscar

异变方法在方法的自行过程中需要写入访问到 self ，并且输入输出形式参数同时也需要写入访问到 teammate 。在方法中， self 和 teammate 实际上引用自同一内存地址——如图所示。这两个写入访问引用到了同一个地址并重叠，产生冲突。

属性的访问冲突

像是结构体、元组以及枚举这些类型都是由独立值构成，比如结构体的属性或者元组的元素。由于这些都是值类型，改变任何一个值都会改变整个类型，意味着读或者写访问到这些属性就需要对整个值进行读写访问。比如说，对元组的元素进行重叠写入访问就会产生冲突：

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// Error: conflicting access to properties of playerInformation

在上边例子中，在同一元组的元素上调用 balance(_:_:) 产生冲突是因为对 playerInformation 产生了重叠写入访问。 playerInformation.health 和 playerInformation.energy 作为输入输出形式参数传入，这就意味着 balance(_:_:) 在函数调用的过程中对他们产生写入访问。在这两种情况下，对元组元素的写入访问需要整个元组的写入访问。也就是说 playerInformation 在调用过程中有两个写入访问重叠，导致冲突。

下面的代码显示了对全局变量结构体属性的重叠写入访问，导致同样的错误。

var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy)  // Error

实际上，大多数对结构体属性的访问可以安全的重叠。比如果，如果上边变量 holly 变成局部变量而不是全局变量，那么编译器就可以保证重叠访问结构体的存储属性是安全的：

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // OK
}

在上边的例子中，Oscar 的血条和能量作为两个输入输出形式参数传递给了 balance(_:_:) 。编译器可以证明内存安全得以保证是因为两个存储属性不会以任何形式交互。

• 你只访问实例的存储属性，不是计算属性或者类属性；
• 结构体是局部变量而非全局变量；
• 结构体要么没有被闭包捕获要么只被非逃逸闭包捕获。

如果编译器不能保证访问是安全的，它就不允许访问。