Swift使用逃逸闭包时为何需复制inout参数？（学习用途）

可运行的延迟计算实现 #

以下Swift代码用于学习延迟计算（类似惰性求值）的实现，目前只有创建inout参数的本地副本才能正常运行：

func myMult(_ x: Int, _ computeValue: @escaping () -> Int) -> Int { 
    if x == 0 {
        return 0
    } else if x == 1 {
        return computeValue()
    } else {
        return computeValue() + myMult(x - 1, computeValue)
    }
}


func myDelay(_ th: @escaping () -> Int) -> (Bool, () -> Int) {
    return (false, th)  
}


func myForce(_ p: inout (Bool, () -> Int) ) -> Int {
    if p.0 {
        return p.1()
    } else {
        let local_p = p.1
        p.0 = true
        p.1 = { local_p() }
    }
    
    return p.1()
}


// (false, (Function))
var myDelayedResult = myDelay({2 + 3})

// false
myDelayedResult.0
// 5
myDelayedResult.1()

// 1500
myMult(300, {myForce(&myDelayedResult)})

// (true, (Function))
myDelayedResult

核心问题：移除本地副本后的报错 #

如果去掉local_p直接捕获inout参数p，会触发编译错误：

func myForce(_ p: inout (Bool, () -> Int) ) -> Int {    
    if p.0 {
        return p.1()
    } else {
        p.0 = true
        // error: Escaping closure captures 'inout' parameter 'p'
        p.1 = { p.1() }
    }
    
    return p.1()
}

相关限制说明：Swift不允许逃逸闭包捕获inout参数，因为inout参数仅在函数调用期间有效，将其存入逃逸闭包可能导致函数结束后访问无效内存。

针对问题的解答 #

1. 是否需要对inout参数p解引用？ #

不需要，因为Swift的inout和C语言的指针不是同一概念：

• C指针直接对应内存地址，可长期持有；而Swift的inout是函数调用时的临时引用绑定，函数执行完毕后，这个绑定就会失效，内存访问权限被收回。
• 尝试{ inout p.1() }这类写法本身不符合Swift语法，inout只能用于函数参数声明，不能在闭包内部这样使用。
• 必须通过创建本地副本（比如local_p）来捕获需要的内容，因为本地变量的生命周期不受原inout参数的限制。

2. 无inout的函数式实现能否避免本地副本？ #

不能，因为你使用的元组(Bool, () -> Int)是值类型：

• 值类型在传递时会创建完整副本，函数内部修改副本不会影响外部原变量。
• 你提供的无inout实现中，必须创建var tuple = p的本地副本，否则无法修改元组的属性（原参数p是let常量），但即便修改了副本，外部的myDelayedResult也不会同步更新，这就是最后打印myDelayedResult仍为(false, (Function))的原因。

3. 如何用数组（引用类型）实现myDelay而无需自定义类型？ #

数组是Swift的引用类型，我们可以把延迟计算的状态包装在数组中，这样函数内部修改数组元素会直接影响外部原变量：

func myMult(_ x: Int, _ computeValue: @escaping () -> Int) -> Int { 
    if x == 0 {
        return 0
    } else if x == 1 {
        return computeValue()
    } else {
        return computeValue() + myMult(x - 1, computeValue)
    }
}

// 用数组包装状态，数组是引用类型
func myDelay(_ th: @escaping () -> Int) -> [ (Bool, () -> Int) ] {
    return [ (false, th) ]
}

func myForce(_ p: [ (Bool, () -> Int) ]) -> Int {
    if p[0].0 {
        return p[0].1()
    } else {
        let result = p[0].1()
        // 修改数组内的元组（因为数组是引用类型，外部会同步更新）
        p[0] = (true, { result })
        return result
    }
}

var myDelayedResult = myDelay({2 + 3})

// false
print(myDelayedResult[0].0)
// 5
print(myDelayedResult[0].1())

// 1500
print(myMult(300, { myForce(myDelayedResult) }))

// (true, (Function))
print(myDelayedResult[0])

这个实现中，数组作为引用容器，函数内部修改数组元素时，外部的myDelayedResult会同步更新状态，无需自定义类或结构体。

内容的提问来源于stack exchange，提问作者Adrian