Question

请考虑以下代码：

func foo(inout success: Bool) -> (()->()) {
    return { _ in
        success = true
        print (success)
    }
}

var success = false
let closure = foo(&success)

closure()          //prints "true"
print(success)     //prints "false"

封闭似乎创造了成功的副本，并没有改变原作。为什么会这样？我假设闭包会指向原文，因为我们传递的是inout变量。

Answer 1

有意义的是，这不会更新您的success变量，因为您的inout参数是foo的参数，而不是闭包本身。如果将inout参数设为闭包的参数，则会得到所需的行为：

var success = false
let closure = { (inout flag: Bool) -> () in
    flag = true
    print(flag)
}

closure(&success)  //prints "true"
print(success)     //prints "true"

只要您将inout参数保留为闭包的参数，此模式也适用于该函数：

func foo() -> ((inout Bool)->()) {
    return { flag in
        flag = true
        print (flag)
    }
}

var success = false
let closure = foo()

closure(&success)  //prints "true"
print(success)     //prints "true"

如果使用引用类型，也会获得所需的行为：

class BooleanClass: CustomStringConvertible {
    var value: Bool

    init(value: Bool) {
        self.value = value
    }

    var description: String { return "\(value)" }
}

func foo(flag: BooleanClass) -> (()->()) {
    return {
        flag.value = true
        print (flag)
    }
}

let success = BooleanClass(value: false)
let closure = foo(success)

closure()          //prints "true"
print(success)     //prints "true"

Answer 2

这似乎由Swift Evolution proposal 0035涵盖，并被视为错误。

该文档将函数的inout参数称为＆＃34; 卷影副本，当被调用者返回＆＃34;时，该参数将被写回参数。这似乎意味着在success的执行上下文中实际上存在一个名为foo()的临时变量。然后，只有当success返回时，该temp的值才会被放入外部foo()。

因为在你的foo()中，当foo()返回时，闭包没有运行，＆＃34; shadow copy＆＃34;没有改变。外success保留其值。

重要的一点是，关闭已经捕获了卷影副本 ，而不是您期望的外部success。因此，当闭包最终运行时，该变量的值确实会发生变化，但它不再与原始外部success建立任何连接。

该提案使用此代码段演示：

func captureAndEscape(inout x: Int) -> () -> Void {
  let closure = { x += 1 }
  closure()
  return closure
}

var x = 22
let closure = captureAndEscape(&x)
print(x) // => 23
closure()
print("still \(x)") // => still 23

Swift闭包捕获和inout变量

2 个答案: