考虑以下用例:

在某些游戏的模型中，您有一个 Player 类。每个 Player 都有一个 unowned let optional: Player 代表他们正在对战的对手。这些总是成对创建的，并且 Player 必须始终有一个 opponent 因为它是非可选的。然而，这很难建模，因为必须先创建一个玩家，而第一个玩家只有在创建第二个玩家之后才会有对手!

通过一些丑陋的黑客攻击，我想出了这个解决方案:

class Player {
    private static let placeholder: Player = Player(opponent: .placeholder, name: "")

    private init(opponent: Player, name: String) {
        self.opponent = opponent
        self.name = name
    }

    unowned var opponent: Player
    let name: String

    class func getPair(named names: (String, String)) -> (Player, Player) {
        let p1 = Player(opponent: .placeholder, name: names.0)
        let p2 = Player(opponent: p1, name: names.1)
        p1.opponent = p2
        return (p1, p2)
    }
}

let pair = Player.getPair(named:("P1", "P2"))

print(pair.0.opponent.name)
print(pair.1.opponent.name)

效果很好。但是，我无法将 opponent 变成常量。一种解决方案是使 opponent 成为没有 set 的计算属性，由私有(private) var 支持，但我想避免这种情况。

我尝试使用 Swift 指针进行一些修改，并提出:

class func getPair(named names: (String, String)) -> (Player, Player) {
    var p1 = Player(opponent: .placeholder, name: names.0 + "FAKE")
    let p2 = Player(opponent: p1, name: names.1)

    withUnsafeMutablePointer(to: &p1) {
        var trueP1 = Player(opponent: p2, name: names.0)
        $0.moveAssign(from: &trueP1, count: 1)
    }
    return (p1, p2)
}

但这会导致段错误。此外，在使用 lldb 进行调试时，我们可以看到，就在 p1 初始化之后，我们有:

(lldb) p p1
(Player2.Player) $R3 = 0x0000000101004390 {
  opponent = 0x0000000100702940 {
    opponent = <uninitialized>
    name = ""
  }
  name = "P1FAKE"
}

但是在函数的最后，lldb 显示了这个:

(lldb) p p1
(Player2.Player) $R5 = 0x00000001010062d0 {
  opponent = 0x00000001010062a0 {
    opponent = 0x0000000101004390 {
      opponent = 0x0000000100702940 {
        opponent = <uninitialized>
        name = ""
      }
      name = "P1FAKE"
    }
    name = "P2"
  }
  name = "P1"
}

(lldb) p p2
(Player2.Player) $R4 = 0x00000001010062a0 {
  opponent = 0x0000000101004390 {
    opponent = 0x0000000100702940 {
      opponent = <uninitialized>
      name = ""
    }
    name = "P1FAKE"
  }
  name = "P2"
}

所以 p1 正确指向 p2，但是 p2 仍然指向旧的 p1。更何况，p1居然改地址了!

我的问题有两个方面:

1. 是否有更简洁、更“快速”的方法来创建这种相互非可选引用的结构？

2. 如果不是，我对 Swift 中的 UnsafeMutablePointer 之类的东西有什么误解，导致上述代码无法运行？

最佳答案

我认为隐式展开可选 是您想要的。您用感叹号 (!) 声明它。这是对编译器的 promise ，即使该属性可能在 init 调用期间被初始化，但在您使用它时它将具有有效值。将其与私有(private) setter 相结合，您可以实现您想要的:

class Player: CustomStringConvertible {
    var name: String
    private(set) weak var opponent: Player!

    init(name: String) {
        self.name = name
    }

    class func getPair(named names: (String, String)) -> (Player, Player) {
        let p1 = Player(name: names.0)
        let p2 = Player(name: names.1)

        p1.opponent = p2
        p2.opponent = p1
        return (p1, p2)
    }

    var description: String {
        return self.name
    }
}

let (p1, p2) = Player.getPair(named: ("Player One", "Player Two"))
print(p1.opponent) // Player Two
print(p2.opponent) // Player One

由于 setter 是私有(private)的，如果您尝试更改它，编译器将抛出错误:

let p3 = Player(name: "Player Three")
p1.opponent = p3 // Error: Cannot assign to property: 'opponent' setter is inaccessible

请注意，由于您打算让 getPair 成为创建 Player 实例的单一方法，因此您也可以设置 init 调用私有(private)，因为它没有设置 opponent 属性:

private init(name: String) {
    // ...
}

关于swift - Swift 中的相互非可选引用循环，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40027012/