Swift 内存管理是如何工作的？

具体来说，Swift 内存管理如何使用委托模式与选项一起工作？

由于习惯了用 Objective-C 编写委托模式，我的本能是让委托weak。例如，在 Objective-C 中：

@property (weak) id<FooDelegate> delegate;

然而，在 Swift 中执行此操作并不是那么简单。

如果我们有一个看起来很普通的协议：

protocol FooDelegate {
    func doStuff()
}

我们不能将这种类型的变量声明为弱：

weak var delegate: FooDelegate?

产生错误：

“weak”不能应用于非类类型“FooDelegate”

所以我们要么不使用关键字weak，这允许我们使用structs and enums作为代表，或者我们将协议更改为以下内容：

protocol FooDelegate: class {
    func doStuff()
}

这允许我们使用weak，但不允许我们使用structs or enums.

如果我不让我的协议成为类协议，因此不要使用weak对于我的变量，我正在创建一个保留周期，对吗？

是否有任何可以想象的原因，为什么任何打算用作委托协议的协议不应该是类协议，以便这种类型的变量可以weak?

我主要是问，因为在授权部分Apple 关于 Swift 协议的官方文档 https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_415，他们提供了一个非类协议和用作其类的委托的非弱变量的示例：

protocol DiceGameDelegate {
    func gameDidStart(game: DiceGame)
    func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)
    func gameDidEnd(game: DiceGame)
}

class SnakesAndLadders: DiceGame {
    let finalSquare = 25
    let dice = Dice(sides: 6, generator: LinearCongruentialGenerator())
    var square = 0
    var board: [Int]
    init() {
        board = [Int](count: finalSquare + 1, repeatedValue: 0)
        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
        board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
    }
    var delegate: DiceGameDelegate?
    func play() {
        square = 0
        delegate?.gameDidStart(self)
        gameLoop: while square != finalSquare {
            let diceRoll = dice.roll()
            delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)
            switch square + diceRoll {
            case finalSquare:
                break gameLoop
            case let newSquare where newSquare > finalSquare:
                continue gameLoop
            default:
                square += diceRoll
                square += board[square]
            }
        }
        delegate?.gameDidEnd(self)
    }
}

我们是否应该将此视为 Apple 认为我们应该使用结构体作为委托的暗示？或者这只是一个糟糕的例子，实际上，委托协议应该声明为仅类协议，以便委托对象可以持有对其委托的弱引用？

我们是否应该将此视为 Apple 认为我们应该使用结构体作为委托的暗示？或者这只是一个糟糕的例子，实际上，委托协议应该声明为仅类协议，以便委托对象可以持有对其委托的弱引用？

事情是这样的。在现实生活中的 Cocoa 编程中，委托很可能是一个现有的类。它是一个类，因为它的存在是为了某些只有类才能满足的其他目的 - 因为可可需要它.

例如，通常以 iOS 为例，一个视图控制器需要充当另一个视图控制器的委托，以便在它们之间来回安排消息。视图控制器的所有权由视图控制器层次结构决定，而不是由其他任何东西决定。所以，在 Swift 中，就像在 Objective-C 中一样，你有better做到这一点delegate财产weak，因为如果一个视图控制器突然夺取了另一个视图控制器的内存管理所有权，那将是可怕的！

因此，在 Cocoa 框架的现实世界中，存在不正确的所有权或保留周期的严重危险。这就是问题所在weak解决。但正如你所说，它只适用于课程。

然而，书中的例子是关于一些生活在抽象的人造 Swift 世界中的对象。在那个世界中，只要您不面临循环（保留循环）的危险，就没有理由不使用结构，也没有理由担心内存管理。但那个世界并不是您通常编程的世界！这个世界并不是你的 Objective-C 委托模式所来自和所属的框架 Cocoa 世界。