Swift inout

转自

题目：二叉树遍历

class TreeNode {  
    var val: Int  
    var left: TreeNode?  
    var right: TreeNode?  
}

前序遍历

func preorderTraversal(_ root: TreeNode?) -> [Int] {  
    var result: [Int] = []  
    guard let root = root else { return result } // 如果根节点为空，直接返回空数组  
      
    // 递归实现前序遍历  
    preorderTraversalHelper(root, &result)  
      
    return result  
}  
  
func preorderTraversalHelper(_ node: TreeNode, _ result: inout [Int]) {  
    if let node = node {  
        // 访问根节点  
        result.append(node.val)  
        // 遍历左子树  
        preorderTraversalHelper(node.left, &result)  
        // 遍历右子树  
        preorderTraversalHelper(node.right, &result)  
    }  
}

//中序遍历

func inorderTraversal(_ root: TreeNode?) -> [Int] {  
    var result: [Int] = []  
    guard let root = root else { return result } // 如果根节点为空，直接返回空数组  
      
    // 递归实现中序遍历  
    inorderTraversalHelper(root, &result)  
      
    return result  
}  
  
func inorderTraversalHelper(_ node: TreeNode, _ result: inout [Int]) {  
    if let node = node {  
        // 遍历左子树  
        inorderTraversalHelper(node.left, &result)  
        // 访问根节点  
        result.append(node.val)  
        // 遍历右子树  
        inorderTraversalHelper(node.right, &result)  
    }  
}

后续遍历

func postorderTraversal(_ root: TreeNode?) -> [Int] {  
    var result: [Int] = []  
    guard let root = root else { return result } // 如果根节点为空，直接返回空数组  
      
    // 递归实现后序遍历  
    postorderTraversalHelper(root, &result)  
      
    return result  
}  
  
func postorderTraversalHelper(_ node: TreeNode, _ result: inout [Int]) {  
    if let node = node {  
        // 遍历左子树  
        postorderTraversalHelper(node.left, &result)  
        // 遍历右子树  
        postorderTraversalHelper(node.right, &result)  
        // 访问根节点  
        result.append(node.val)  
    }  
}

inout是 Swift 中的关键字，可以放置于参数类型前，冒号之后。使用 inout之后，函数体内部可以直接更改参数值，而且改变会保留。

func swap(resSct: inout ResolutionStruct) {
withUnsafePointer(to: &resSct) { print("During calling: ($0)") }
let temp = resSct.height
resSct.height = resSct.width
resSct.width = temp
}

var iPhone6ResoStruct = ResolutionStruct(height: 1334, width: 750)
print(iPhone6ResoStruct)
withUnsafePointer(to: &iPhone6ResoStruct) { print("Before calling: (0)") }
小结：值类型变量作为参数传入函数，外界和函数参数的内存地址一致，函数内对参数的更改得到了保留。
需要注意的是：
1.使用 inout 关键字的函数，在调用时需要在该参数前加上 & 符号
2.inout 参数在传入时必须为变量，不能为常量或字面量（literal）
3.inout 参数不能有默认值，不能为可变参数
4.inout 参数不等同于函数返回值，是一种使参数的作用域超出函数体的方式
5.多个inout 参数不能同时传入同一个变量，因为拷入拷出的顺序不定，那么最终值也不能确定

struct Point {
var x = 0.0
var y = 0.0
}

struct Rectangle {
var width = 0.0
var height = 0.0
var origin = Point()

var center: Point {
    get {
        print("center GETTER call")
        return Point(x: origin.x + width / 2,
                     y: origin.y + height / 2)
    }
    
    set {
        print("center SETTER call")
        origin.x = newValue.x - width / 2
        origin.y = newValue.y - height / 2
    }
}

func reset(center: inout Point) {
    center.x = 0.0
    center.y = 0.0
}

}

var rect = Rectangle(width: 100, height: 100, origin: Point(x: -100, y: -100))
print(rect.center)
rect.reset(center: &rect.center)
print(rect.center)

// center GETTER call
// Point(x: -50.0, y: -50.0)

// center GETTER call
// center SETTER call

// center GETTER call
// Point(x: 0.0, y: 0.0)
inout参数的传递过程：

当函数被调用时，参数值被拷贝
在函数体内，被拷贝的参数修改
函数返回时，被拷贝的参数值被赋值给原有的变量