考虑以下常见的简单类型删除方案

protocol Foo {
    associatedtype Bar
    func bar() -> Bar
}

struct AnyFoo<Bar>: Foo {
    private let _bar: () -> Bar

    init<F: Foo>(_ foo: F) where F.Bar == Bar {
        _bar = foo.bar
            /* stores a reference to foo.bar,
               so foo kept alive by ARC? */
    }

    func bar() -> Bar {
        return _bar()
    }
}

假设上面的初始化参数 foo 是(打算成为)“大”类型的临时实例，我们只对从中切出 Foo 蓝图的信息感兴趣(即 bar() 方法)。

struct Huge { /* ... */ }

struct Foobar: Foo {
    internal func bar() -> String {
        return "foo"
    }
    let lotsOfData: Huge = Huge()
}

func getAnyFooStr() -> AnyFoo<String> {
    let foobar = Foobar()
    return AnyFoo(foobar)
}

let anyStrFoo = getAnyFooStr()
    /* we can now access anyStrFoo.bar() (-> "foo") from our
       erased type, but do lotsOfData of the underlying seemingly
       temporary Foobar() instance still "live", unreachable? */

• 问:由于闭包是引用类型，我们是否仍会在内存中保留 foo 的剩余内容且无法访问？如果是这样，我想我们将永远无法收回对这些丢失但仍然存在的内容的访问权限？

(我用 Foobar 作为一个类尝试了上面的方法，监控(缺少)deinit 调用，但我把自己弄糊涂了最后一小时，我需要为此进行一些非 self 验证，特别是对于 Foobar 是值类型的情况)

Xcode 8.0/Swift 3。

最佳答案

是的，它与类型删除无关:) 闭包 Foobar().bar 保留它绑定(bind)的实例 (及其所有属性)只要闭包还活着。

这是一个简化的例子:

class Huge {
    deinit { print("deinit Huge") }
}

struct Foobar {
    internal func bar() -> String {
        return "foo"
    }
    let lotsOfData: Huge = Huge()
}

do {
    let fb  = Foobar().bar // the type of `fb` is `() -> String`
    print("still alive ...")
}
print("... out of scope now")

输出:

still alive ...
deinit Huge
... out of scope now

关于swift - 删除类型信息时类型删除: do we risk non-reversibly losing access to kept-alive data of the instance of the erased type,？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39498867/