前段时间出差支援实施兄弟，回来差点忘记自己是干啥的。 [猛男微笑.gif]
准备灌几篇水找找感觉。 [猛男再次微笑.gif]
最近趁着年前空闲重读了 Swift 的文档，一方面看看新增的特性，另一方面则是为了查缺补漏，对以前模糊的东西加深下理解。本文是对 构造过程 和 析构过程 简易介绍。

[难度：入门]

在Swift中，对象在使用前需要进行构造（分配内存、各种初始化），在被废弃后又要经过析构（释放内存及各种资源）。

构造过程

先看一个简单的例子：

// 基类
class Base {
    var id = "Defualt"
}

// 子类
class Test : Base {
    var value = 0
}

let test = Test(value:1)
print("id = \(test.key), value = \(test.value)")
// 输出： id = Defualt, value = 0

子类 Test 继承于基类 Base。两个类各有一个存储属性并且都设置了默认值。最后创建了子类的一个实例，同时打印出子类和父类中属性的值。

程序是在什么时候构建的实例对象？又是在什么时候对子类和父类的变量进行初始化的？

1. “指定构造器” 与 “便利构造器”

指定构造器：类中最主要的构造器。每一个类都必须至少拥有一个指定构造器，指定构造器将初始化类中提供的所有属性，并调用合适的父类构造器使构造过程沿着继承链继续往上进行。

//指定构造器
init(parameters) {
    statements
}

便利构造器：类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为部分形参提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入值的实例。

// 便利构造器
convenience init(parameters) {
   statements
}

指定构造器

从概念中可知每个类至少拥有一个指定构造器，指定构造器是必要的且要初始化所有的属性。例子中并没有实现任何构造器只对属性赋予了初始值，程序也一样正常运行，这是因为程序自动添加了默认构造器，默认构造器形式如下

init() {
}

一个最最简单的init函数，为什么指定构造器是必要的？因为在指定构造器运行完成后，实例才会真正被创建，程序在指定构造器中初始化所有的属性。也可以自己实现自己的指定构造器，比如在Base中添加：

init(someValue:Int) {
}

需要注意的是，当开发者自己定义了一个指定构造器后，满足了至少拥有一个指定构造器的定义，程序将不会再生成默认构造器。当Base添加了该指定构造器后，就不能再使用 Base() 来进行构建，而只能使用 Base(someValue:)。

指定构造器的定义是初始化所有属性，可例子中添加的指定构造器没有任何行为，这是因为在属性定义的时候就赋予默认值，而程序则是在运行指定构造器构建对象时才会将默认值赋予给指定的属性，也就是说，属性真正的初始化在指定构造器中。为了测试，将Base中属性的默认赋值取消掉：

class Base {
    var id:String
    
    init(someValue:Int) {
        // Error:Return from initializer without initializing all stored properties
    }
}

此时，编译器在自定义的指定构造器中触发了错误。在指定构造器中添加对id属性的赋值即可恢复正常。

也可以将属性设置为”可选"(var id:String?)，这样就不需要手动赋予属性初始值，程序在构建会将属性初始化为nil，更多详情请参考"可选类型"。

指定构造器的定义中还有一个特点-指定构造器会调用父类的指定构造器，使构造过程沿着父类链继续往上进行，下面介绍"构造链"时会详细说明。

便利构造器

便利构造器在 init 前用 convenience 标识，可以不为属性赋值。意味着便利构造器不符合"实例初始化完成前对所有属性初始化"的特点，所以便利构造器必须调用同类中的指定构造器，上面已经介绍了指定构造器会强制检测所有属性是否完成初始化，并且会自动调用父类的指定构造器完成整个"构造链"，这也是便利构造器依旧被称为“构造器”的原因。

在基类Base中添加个便利构造器：

class Base {
    var id:String = "Default"

    convenience init(someValue:Int) {
        // 此处调用了程序自动生成的指定构造器(默认构造器)
        self.init()
    }
}

在某些必要的时候可以使用便利构造器，为类调用指定构造器，在复杂的类中能够节省更多开发时间并让类的构造过程更清晰明了。

2.构造链

上面的例子都是在基类中，实际开发中使用的类可能经过了多层继承，下面来看看经过多层继承的类在构造时的过程。给上面的例子稍微加点料：

class Base {
    var id:String
    
    init() {
        print("3")
        self.id = "Default"
        print("4")
    }

    convenience init(someValue:Int) {
        print("a")
        self.init()
        print("b")
    }
}

class Test : Base {
    var value:Int

    init(value:Int) {
        print("2")
        self.value = value
        super.init()
        self.test()
        print("5")
    }
    
    convenience init(otherData:String) {
        print("1")
        self.init(value:0)
        print("6")
    }
    
    func test() {}
}

let test = Test(otherData: "")
// 输出:1 2 3 4 5 6
let base = Base(someValue: 1)
// 输出:a 3 4 b

分别调用子类与基类的便利构造器。为了便于理解，调用子类便利构造器构建的过程输出的数字就是运行的顺序。文字描述过程如下：

1. 开始调用子类便利构造器
2. 子类便利构造器中调用了子类的指定构造器
3. 完成子类所有属性初始化后调用基类的指定构造器
4. 完成基类的所有属性初始化并完成基类初始化
5. 返回子类指定构造器完成子类初始化
6. 返回子类便利构造器
7. 结束

由上可知：可以将Swift的构造过程看做两段式:

[向上]：以指定构造器机制顺着继承链向上逐级调用指定构造器完成属性的初始化以及对象的初始化，直到基类（没有父类的类）。
[向下]：从基类顺着向上过程中所调用的构造器方法逐个返回，依次完成诸如修改属性值，调用指定函数等自定义初始化。

这里借助官方文档的图片来理解流程将更加清晰：

构造过程.png

更加复杂的构造过程原理是相同的：

复杂的构造过程.png

借助两类构造器的定义来理解过程将会很简单：便利构造器只能调用同类中的其他构造器，指定构造器只能调用父类中的指定构造器。

注意到子类指定构造器中调用子类方法test()部分了么，是否可以把它写在 super.init()之前？为什么？

要回答这个问题就要更加深入理解Swift的构造过程中细节。就像同一个方法里可以通过self来调用属性进行初始化，却不能调用实例方法，这其实是Swift的安全检查之一-在完成第一阶段构造（向上）时，不能通过self来调用实例方法。，其他的安全检查在上面都有涉及，这里直接借用官方文档的描述加深下印象：

1. 指定构造器必须保证它所在类的所有属性都必须先初始化完成，之后才能将其它构造任务向上代理给父类中的构造器。
   如上所述，一个对象的内存只有在其所有存储型属性确定之后才能完全初始化。为了满足这一规则，指定构造器必须保证它所在类的属性在它往上代理之前先完成初始化。
2. 指定构造器必须在为继承的属性设置新值之前向上代理调用父类构造器。如果没这么做，指定构造器赋予的新值将被父类中的构造器所覆盖。
   安全检查
3. 便利构造器必须为任意属性（包括所有同类中定义的）赋新值之前代理调用其它构造器。如果没这么做，便利构造器赋予的新值将被该类的指定构造器所覆盖。
4. 构造器在第一阶段构造完成之前，不能调用任何实例方法，不能读取任何实例属性的值，不能引用 self 作为一个值。
   类的实例在第一阶段结束以前并不是完全有效的。只有第一阶段完成后，类的实例才是有效的，才能访问属性和调用方法。

构造过程到这里就差不多了，但Swift的构造不仅仅只有过程需要掌握，还有可失败构造器(init?)、构造器重写(override)、结构体的默认构造器 等相关知识，详细的可阅读官方文档，这里就不再展开。

析构过程

当对象（Class）不再被需要时，程序就会释放掉相关资源，这个释放的过程被称为析构。析构方法固定使用deinit方法，每个类只能有一个析构器,在实例释放发生前自动调用。

deinit {
    // 执行析构过程
}

同样的，举一个简单的例子：

class Base {
    deinit { print("base free") }
}

class Demo : Base {
    deinit { print("demo free") }
}

func test() {
    let _ = Demo()
}

test()
print("end")
// 输出：
// demo free
// base free
// end

在test()中创建了一个Demo实例，随着test结束，作为局部变量的Demo实例也会被释放，从输出结果可以得知，程序沿着继承链自动调用了析构方法。当继承链上的所有析构方法都被调用完毕后，程序就会释放对象所占用的内存。析构的过程比构造过程简单很多。

扩展思考：
为什么结构体没有 deinit ? (结合值类型的特点)

总结

不论是构造还是析构，都借助继承链来完成，析构过程非常简单，构造过程要注意指定构造器与便利构造器的特点，以及整个构造过程向上向下的二段式特点。

更多深入学习请参考官方文档或者国内的汉化翻译SwiftGG