Swift:通过指针访问计算属性

Question

我正在尝试通过指向该属性的指针来获取/设置对象的计算属性。我在下面包含了代码片段和输出。

该片段的要点是有一个类 Foo 具有计算属性 bar。 Mutator 类保留一个指针并有一个计算属性 value，它只获取/设置它指向的值。因此，如果我创建 f1: Foo，然后创建一个引用该 f1.bar 的 m1: Mutator 对象，我会认为设置 m1.value 也会设置 f1.bar1。它有时有效，但并非总是如此。

//---------------------------------------------------------------------------
// Class definitions

class Foo
{
    private var data = [String: Double]()

    var bar: Double? 
    {
        get { return self.data["bar"] }
        set { self.data["bar"] = newValue }
    }       

    init(_ key: String, _ val: Double)
    {
        self.data[key] = val
    }
}

class Mutator
{
    let name: String
    let storage: UnsafeMutablePointer<Double?>

    var value: Double?
    {
        get { return self.storage.pointee }
        set { self.storage.pointee = newValue}
    }

    init(name: String, storage: UnsafeMutablePointer<Double?>)
    {
        self.name = name
        self.storage = storage
    }

}

//---------------------------------------------------------------------------
// Create and display mutators directly

print("-\nCreate and display mutator directly")

let f1 = Foo("bar", 1.1)
let f2 = Foo("bar", 2.2)
let f3 = Foo("bar", 3.3)

let m1 = Mutator(name:"mf1", storage: &f1.bar) // Or, let m1 = Mutator(name:"f1", storage: UnsafeMutablePointer<Double?>(&f1.bar))
let m2 = Mutator(name:"mf2", storage: &f2.bar)
let m3 = Mutator(name:"mf3", storage: &f3.bar)

var before = m1.value
m1.value = 199.1
var after = m1.value
print("\(m1.name): before=\(before), after=\(after) @ \(m1.storage)")   

before = m2.value
m2.value = 299.2
after = m2.value
print("\(m2.name): before=\(before), after=\(after) @ \(m2.storage)")

before = m3.value
m3.value = 299.2
after = m3.value
print("\(m3.name): before=\(before), after=\(after) @ \(m3.storage)")

//---------------------------------------------------------------------------
// Create mutators inside function

func createMutators() -> [Mutator]
{   
    print("-\nIn createMutators function ...")

    let m1 = Mutator(name:"mf1", storage: &f1.bar)
    let m2 = Mutator(name:"mf2", storage: &f2.bar)  
    let m3 = Mutator(name:"mf3", storage: &f3.bar)

    print("\(m1.name)=\(m1.value) @ \(m1.storage)")
    print("\(m2.name)=\(m2.value) @ \(m2.storage)")
    print("\(m3.name)=\(m3.value) @ \(m3.storage)")

    return [m1, m2, m3] 
}

let mutator = createMutators()

//---------------------------------------------------------------------------
// Display mutators returned by function

print("-\nDisplay mutator returned by function")
for m in mutator
{
    let before = m.value
    m.value = 10.0 + (before ?? Double.nan)
    let after = m.value

    print("\(m.name): before=\(before), after=\(after) @ \(m.storage)") 
}

如果我在 Linux 上运行上面的代码，我会得到以下输出:

Create and display mutator directly
mf1: before=Optional(1.1000000000000001), after=Optional(199.09999999999999) @ 0x00007ffd38f82730
mf2: before=Optional(2.2000000000000002), after=Optional(299.19999999999999) @ 0x00007ffd38f82708
mf3: before=Optional(3.2999999999999998), after=Optional(299.19999999999999) @ 0x00007ffd38f826e0
-
In createMutators function ...
mf1=Optional(1.1000000000000001) @ 0x00007ffd38f82288
mf2=Optional(2.2000000000000002) @ 0x00007ffd38f82260
mf3=Optional(3.2999999999999998) @ 0x00007ffd38f82238
-
Display mutator returned by function
mf1: before=Optional(4.9406564584124654e-324), after=Optional(10.0) @ 0x00007ffd38f82288
mf2: before=Optional(6.9527664311957093e-310), after=Optional(10.0) @ 0x00007ffd38f82260
mf3: before=nil, after=Optional(nan) @ 0x00007ffd38f82238

第一个输出 block 显示了预期的行为。第二个 block 指向不同的地址，这是意想不到的。更奇怪的是，尽管地址错误，但它读取了正确的值。最后一个输出 block 与第二个 block 具有相同的地址，但读取不同的初始值，尽管它确实设法正确设置和读回值。

我知道这可能是对计算属性和指针的滥用。但是谁能解释为什么它有时会起作用？为什么在函数中创建它会给它一个不同的地址？本地址相同时，为什么在函数中读取它并在返回后给出不同的答案？有什么办法可以做到这一点吗？

只是为了进一步混淆:以上是在 Linux 上运行的。当我在 Mac 上尝试这个实验时，我得到了一些不同的结果，尽管有时它有效的总体观察仍然是正确的。

Answer 1

这些都不是定义的行为。它可能会或可能不会产生预期的结果，或者它可能只是在运行时崩溃。

当你说

let m1 = Mutator(name:"mf1", storage: &f1.bar)

Swift 将分配一些内存并将其初始化为 f1.bar 的 getter 返回的值。然后，指向此内存的指针将被传递到 Mutator 的 init - 在调用之后，Swift 将调用 f1.bar 的setter 与它分配的内存的(可能改变的)内容。

此内存将被释放——指针现在不再有效。读取和写入其 pointee 将产生未定义的行为。因此，您应该不在调用Mutator 的初始化程序后保留指针。

为了获得您想要的行为，一种方法是使用两个闭包来获取和设置 f1.bar，两者都捕获 f1。这确保只要闭包存在，对 f1 的引用就保持有效。

例如:

struct Mutator<T> {

    let getter: () -> T
    let setter: (T) -> Void

    var value: T {
        get {
            return getter()
        }
        nonmutating set {
            setter(newValue)
        }
    }

    init(getter: @escaping () -> T, setter: @escaping (T) -> Void) {
        self.getter = getter
        self.setter = setter
    }
}

然后你可以像这样使用它:

class Foo {
    private var data = [String : Double]()

    var bar: Double? {
        get { return self.data["bar"] }
        set { self.data["bar"] = newValue }
    }

    init(_ key: String, _ val: Double) {
        self.data[key] = val
    }
}


let f1 = Foo("bar", 1.1)
let m1 = Mutator(getter: { f1.bar }, setter: { f1.bar = $0 })

let before = m1.value
m1.value = 199.1

print("m1: before = \(before as Optional), after = \(m1.value as Optional)")
print("f1 after = \(f1.bar as Optional)")

// m1: before = Optional(1.1000000000000001), after = Optional(199.09999999999999)
// f1 after = Optional(199.09999999999999)

尽管这种方法的一个缺点是您正在获取和设置的值会重复(在本例中为 f1.bar)。一种替代实现方式是使用带有函数参数的单个闭包，该函数参数采用 inout 参数，返回(可能发生变异的)值。

struct Mutator<T> {

    let getter: () -> T
    let setter: (T) -> Void

    var value: T {
        get {
            return getter()
        }
        nonmutating set {
            setter(newValue)
        }
    }

    init(mutator: @escaping ((inout T) -> T) -> T) {

        // a function, which when applied, will call mutator with a function input
        // that just returns the inout argument passed by the caller.
        getter = {
            mutator { $0 }
        }

        // a function, which when applied with a given new value, will call mutator
        // with a function that will set the inout argument passed by the caller
        // to the new value, which will then be returned 
        // (but ignored by the outer function)
        setter = { newValue in
            _ = mutator { $0 = newValue; return $0 }
        }
    }
}

// ...

let f1 = Foo("bar", 1.1)
let m1 = Mutator { $0(&f1.bar) }

getter 现在简单地应用传递的函数，返回传递的 inout 参数(在本例中为 f1.bar)，setter 使用这个 inout 参数以便分配一个新值。

虽然我个人更喜欢第一种方法，尽管有重复。