Swift内存管理如何工作？

但是,在Swift中这样做并不是那么简单.

如果我们只有一个看似正常的协议:

protocol FooDelegate {
    func doStuff()
}

我们不能将此类型的变量声明为弱:

weak var delegate: FooDelegate?

产生错误:

'weak'不能应用于非类型'FooDelegate'

所以我们要么不使用关键字weak,这允许我们使用structs和enums作为代理,或者我们将协议更改为以下内容:

protocol FooDelegate: class {
    func doStuff()
}

这允许我们使用weak,但不允许我们使用structs或enums.

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

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

我主要问一下,因为在关于Swift协议的Apple官方文档的委托部分中,它们提供了一个非类协议和一个非弱变量的示例,用作其类的委托:

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认为我们应该使用结构作为代表的暗示？或者这只是一个不好的例子,并且实际上,委托协议应该被声明为仅类协议,以便委托对象可以保存对其委托的弱引用？