何时使用 inout 参数？

inout意味着修改局部变量也将修改传入的参数。如果没有它，传入的参数将保持相同的值。在使用 inout和值类型而不使用它时，尝试考虑引用类型。

例如:

import UIKit


var num1: Int = 1
var char1: Character = "a"


func changeNumber(var num: Int) {
num = 2
print(num) // 2
print(num1) // 1
}
changeNumber(num1)


func changeChar(inout char: Character) {
char = "b"
print(char) // b
print(char1) // b
}
changeChar(&char1)

一个很好的用例是 swap函数，它将修改传入的参数。

Swift 3 + Note : 从 Swift 3开始，inout关键字必须出现在 之后冒号和类型之前。例如，Swift 3 + 现在需要 func changeChar(char: inout Character)。

来自 苹果语言参考: 声明 In-Out 参数:

作为优化，当参数是存储在物理 地址在内存中，相同的内存位置在内部和 优化后的行为称为调用 引用; 它满足拷贝的所有要求 拷贝模式 同时减少了复制的开销。不依赖 关于复制-在复制-出和呼叫之间的行为差异 参考文献。

如果你有一个函数，采取一个有点内存智能的大值类型作为参数(比如说，一个大结构类型) ，并返回相同的类型，最后，函数返回值总是用来替换调用者的参数，那么 inout更喜欢作为相关的函数参数。

考虑下面的例子，其中的注释描述了为什么我们希望在常规的 type-in-return-type 函数上使用 inout:

struct MyStruct {
private var myInt: Int = 1


// ... lots and lots of stored properties


mutating func increaseMyInt() {
myInt += 1
}
}


/* call to function _copies_ argument to function property 'myHugeStruct' (copy 1)
function property is mutated
function returns a copy of mutated property to caller (copy 2) */
func myFunc(var myHugeStruct: MyStruct) -> MyStruct {
myHugeStruct.increaseMyInt()
return myHugeStruct
}


/* call-by-reference, no value copy overhead due to inout opimization */
func myFuncWithLessCopyOverhead(inout myHugeStruct: MyStruct) {
myHugeStruct.increaseMyInt()
}


var a = MyStruct()
a = myFunc(a) // copy, copy: overhead
myFuncWithLessCopyOverhead(&a) // call by reference: no memory reallocation

另外，在上面的例子中——-忽略内存问题——-inout可以作为一个很好的代码实践，告诉读我们代码的人我们正在改变函数调用者参数(在函数调用参数之前的与号 &隐式地显示)。下面简洁地总结了这一点:

如果希望函数修改参数的值，并且希望 在函数调用结束后要保持的那些更改，定义 而是将该参数作为 in-out 参数。

来自 苹果语言指南: 函数输入输出参数。

有关 inout的详细信息以及它在内存中的实际处理方式(名称 copy-in-copy-out有些误导...)——除了上面的语言指南的链接之外——请参阅以下 SO 帖子:

• 使用 inout 关键字: 是通过引用或通过 copy-in copy-out (/call by value result)传递的参数

(编辑补充: 附加说明)

上面 Lucas Huang 给出的公认答案中的例子试图——在函数范围内使用 inout参数——访问作为 inout参数传递的变量。不建议这样做，并且明确警告不要在参考文献中这样做:

不要访问作为 in-out 参数传递的值，即使 原始参数在当前范围 中可用 函数返回时，对原始文件的更改将被覆盖 值。 不依赖于 按引用调用优化，以尽量避免更改 覆盖

struct MyStruct {
var myStructsIntProperty: Int = 1


mutating func myNotVeryThoughtThroughInoutFunction (inout myInt: Int) {
myStructsIntProperty += 1
/* What happens here? 'myInt' inout parameter is passed to this
function by argument 'myStructsIntProperty' from _this_ instance
of the MyStruct structure. Hence, we're trying to increase the
value of the inout argument. Since the swift docs describe inout
as a "call by reference" type as well as a "copy-in-copy-out"
method, this behaviour is somewhat undefined (at least avoidable).


After the function has been called: will the value of
myStructsIntProperty have been increased by 1 or 2? (answer: 1) */
myInt += 1
}


func myInoutFunction (inout myInt: Int) {
myInt += 1
}
}


var a = MyStruct()
print(a.myStructsIntProperty) // 1
a.myInoutFunction(&a.myStructsIntProperty)
print(a.myStructsIntProperty) // 2
a.myNotVeryThoughtThroughInoutFunction(&a.myStructsIntProperty)
print(a.myStructsIntProperty) // 3 or 4? prints 3.