GeekBand-Swift 第三周笔记（泛型、函数类型、闭包）

泛型、函数类型、闭包

泛型

泛型是什么？简单说来泛型就是泛指的类型，里面可以实例化任何你想要的类型。
比如我想写个函数交换两个数大小：

泛型函数

func exchange (x: inout Int, y: inout Int)
{
    let a = x
    x = y
    y = a 
}
var a = 55
var b = 22
print("a is \(a), b is \(b).")
//输出结果：a is 55, b is 22.
exchange(x: &a, y: &b)
print("After exchange: a is \(a), b is \(b).")
//输出结果：After exchange: a is 22, b is 55. 

好，看起来很完美，可是你有没有发现这个函数只能交换两个整数，如果要交换小数呢？也许你会说，这不简单，把参数类型换成 Double 就好了嘛。可是如果你又想交换两个字符串呢？这样换来换去不是个办法，所以泛型自然应运而生。

func exchange(x: inout T, y: inout T)
{
    let a = x
    x = y
    y = a
}
var a = "xiaoMing"
var b = "xiaoHong"
print("a is \(a), b is \(b).")
//输出结果：a is xiaoMing, b is xiaoHong.
exchange(x: &a, y: &b)
print("After exchange: a is \(a), b is \(b).")
//输出结果：After exchange: a is xiaoHong, b is xiaoMing.

我们把参数类型换成 T ，然后在函数名后面加一个尖括号，也写上T ，实际上你可以写上任何你想写的字符，只要后面参数类型与它保持一致就行了。
一点点小改动，现在我们即可用来交换整数，又可以交换字符串啦。
现在看起来貌似很不错了，可是如果你想比较 a 和 b 大小可能会碰到一点小问题。你如何能保证传进去的参数支持 “<”、“>” 呢？幸好 Swift 早就想好这个问题了，所以引入了泛型约束。

泛型约束

这个怎么用，看代码：

func max(array: [T]) -> T {
    var value=array[0]
    for index in 1..value {
            value=array[index]
        }
    }
    return value
}
var data1=[1,6,3,8,5,2]
var data2=[12.3, 87.6, 77.8, 20.1, 50.2]
let m1=max(array: data1) // m1 = 8
let m2=max(array: data2) // m2 = 87.6

和泛型函数非常类似，我们只是添加了一个泛型的返回值，再让函数名背后的泛型 T 遵循 Comparable 协议，就这么简单？就这么简单。
只要你传进去的类型遵循 Comparable 协议，那你就可以随意调用这个函数，大家可以点进去看看 Comparable 协议都实现了定义了哪些东西。这样，只要我们想拿该类型做什么事，我们就让他遵循什么协议就好了，如果你随意传个自己写的类，那编译器就会提示你错了，非常方便。

• 除了协议约束，还有基类约束，二者语法一样，不再赘述。
• Where 字句约束

func find(sequence :T, item:T.ItemType)->Bool where T.ItemType: Equatable{
 for index in 0..

protocol Container {
associatedtype ItemType //关联类型
func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}

class Stack: Container {

typealias ItemType=T

var items = [T]()

func push(item: T) {
    items.append(item)
}

func pop() -> T {
    return items.removeLast()
}

func append(item: T) {
    self.push(item: item)
}

var count: Int {
    return items.count
}
subscript(i: Int) -> T {
    return items[i]
}

} ```
哇，不要说你看不懂，我也看晕了，怎么又是 T 又是 ItemType ，这都是些什么啊？
不要慌，先看第一个 Container，它是一个协议。其实它的意思如下伪码：

protocol Container {
 func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

是不是有点儿眉目了，这不就是泛型协议吗，Swift 为啥还要画蛇添足搞出一个关联类型出来？稍安勿躁，苹果这么做自然有他的好处了。
参考链接
我简单总结下好处：

• 让代码更简洁清晰，特别是当你的协议需要定义多个泛型类型时
• 可以使用“.”表达式，方便 where 约束
  好了，有了关联类型，我们就可以像上方那样使用 T.ItemType 的语法来用 where 约束了，是不是非常清晰明了，当你定义的 associatedtype 多了之后，好处就更加明显了。

函数类型与闭包

基本概念

闭包是函数类型的实例，而函数类型就是一个指针，类似于类，栈上储存指针，指向堆上的对象。

函数类型内存模型.png

乍一看有点儿犯迷糊？不要紧，一个个来分析。
函数类型是一个指针，它在堆上有两个对象，这两个对象也是指针。一个叫对象指针，一个叫函数指针。

• 对象指针：这个指针并不是每个函数类型的实例都会有，对象指针，看名字就知道它指向的是一个对象，至于什么样的函数类型拥有对象指针，咱们放到变量捕获那儿讲。
• 函数指针：这个指向的就是这个函数类型里面的函数真正内存所在地
  函数类型怎么用呢？你可以将它用在任何使用类型的地方。例如：
• 声明一个变量 var addInt : (Int, Int) -> Int 现在你可以将任何参数是两个 Int 返回值是一个 Int 的函数赋值给 addInt，就像使用一个变量去使用它，只不过现在该变量是一个函数。
• 传递给某个函数作为一个参数
• 将它作为某个函数的返回值
  这两种不具体写出来了，总之当做它是一个类型就可以了。

函数类型实例化

那既然是一个类型，可以被赋值，那它支持哪些函数给它赋值呢？

• 全局函数
• 嵌套函数

//嵌套函数
func algorithmFunction(symbol:String)-> (Double, Double)->Double{
    
    func add(x:Double, y:Double)->Double{
        return x+y
    }
    
    func minus(x:Double, y:Double)->Double{
        return x-y
    }
    
    func multiply(x:Double, y:Double)->Double{
        return x*y
    }
    
    func divide(x:Double, y:Double)->Double{
        return x/y
    }
    
    switch(symbol){
    case "+":
        return add
    case "-":
        return minus
    case "*":
        return multiply
    case "/":
        return divide
    default:
        return add
    }
}
var algorithm=algorithmFunction(symbol: "/")
let result4 = algorithm(600,80)   // result4 = 7.5

• 成员函数（实例方法与静态方法）

闭包

闭包就是函数类型实例，一样可用于变量、参数、返回值，他俩内存模型一致，那为啥要叫这个为闭包呢？说到这里不得不谈谈捕获了，在谈捕获前，想先介绍下内存泄漏。
内存在结构上可以分为堆和栈，栈上的内存由系统分配系统回收又迅捷又方便，不用我们操心。但栈的空间是极其有限的，所以必须要有堆来存放比较庞大的数据，在 Swift 中类和闭包的实例就存放在堆上并且受到 ARC 管理。
基础数值类型、结构、枚举、元组等不受 ARC 管理。
ARC 又叫自动引用计数管理机制，在堆上的对象只要有一个指针指向它，它的引用计数就加一，如图：

引用计数示意.png

FileStream 此时的引用计数就为三，因为有三个指针指向它。当某个对象没有指针引用的时候，表明此对象没有任何利用价值了，ARC 会将引用计数降为零，并且销毁这个对象，释放所占内存。
好，目前看起来非常完美，perfect！可是，大家应该很快就会发现有个小问题：

循环引用.png

这是两个类，每个类都有一个属性，而这个属性刚好又指向这两个类。真是你中有我我中有你不可分离啊，代码大概会是这样：

import Foundation
class Computer{
    var name: String
    var display: Monitor?
    init(name:String){
        self.name=name
        print("Computer init")
    }
    deinit{
        print("Computer deinit")
    }
}
class Monitor{
    var no: Int
    var device: Computer?
    init(no:Int){
        self.no=no
        print("Monitor init")
    }
    deinit{
        print("Monitor deinit")
    }
}
var imac:Computer?
var screen:Monitor?
imac=Computer(name: "Jason's iMac")
screen=Monitor(no: 29)
imac!.display=screen
screen!.device=imac
//imac!.display=nil
imac=nil
screen=nil
/* print : 
Computer init
Monitor init */

！！是不是少了点什么，析构器怎么没被调用？这就是经典的内存泄漏了。看了上面的内存模型，相信大家对这段代码为何会输出如此结构就了解了，这两个类对象还互相指着呢，引用计数都为一，怎么可能会被释放呢？
还好，世界上的聪明人早就猜到会发生这种事所以，我们有了处理这种办法的措施，那就是。。。手工赋值其中一个堆对象指针为 nil ！哈，开个玩笑，其实这也是一种非常好的处理办法，非常灵活，下面我们来看看更普适的方法。

内存泄漏处理办法.png

解决办法也着实简单，只要我们将其中一个强引用指针换成弱引用就 OK 了，也就是说这个弱引用指针将不被算进 ARC 引用计数里去，这样当栈上的两个指针断掉后，两个对象循环引用自然被打破，如图：

弱引用.png

有时人们并不想该对象可被赋值为 nil，所以我们又创造了一个无主引用，和弱引用一样，只是无主引用声明的对象不许为 nil：

无主引用.png

好了下面再来讲捕获。

捕获

捕获.png

这里重点要讲的是捕获生存周期小于闭包对象的参数和局部变量，因为其他的值谈不上捕获，顶多算使用而已，但是这二者却截然不同，我们是真真正正的复制了他们封装在临时对象上，并且闭包的对象指针指向该临时对象。还记得前面讲函数类型时我说过不是所有函数类型的实例都会有这个对象指针吗？
有对象指针有两种情况，一是捕获了类的实例成员，包括实例方法和实例属性；二就是捕获了参数或局部变量。第一种就是将该闭包的对象指针指向该类的实例对象，第二种则是将对象指针指向闭包自己创建的临时对象。
并且，很重要一点，这个对象指针是强引用该对象，这样，大家可能明白又要出事情了。还是先看内存模型吧：

捕获内存模型.png

似乎并没有什么不对，那我们现在思考一种情形。我是一个闭包，我捕获了类的实例成员，这样我的对象指针就将指向该实例对象；我是这个类，我定义了一个属性，该属性是这个闭包，这样我的实例对象就将有一个属性指针指向该闭包。看代码：

class Employee{
    var name: String
    var printer:(()->())?  
 /*   lazy var printer: (()->())? = {
        print("name: \(self.name)")
    } */
   init(name:String){
        self.name=name
        self.printer = {
            print("name: \(self.name)")
        }
        print("Employee init")
    }
     deinit {
     print("Employee deinit")
    }
}
var employee:Employee?
employee=Employee(name: "Jason")
employee?.printer?()
//employee?.printer=nil
employee = nil
/* print : 
Employee init
name: Jason */

同样析构器不会被调用，因为闭包和这个对象还两两相指呢，只有当我手动赋值该对象的闭包属性为 nil 时，析构器才会调用。看图：

闭包循环引用.png

那解决办法大家应该也猜到了，同样是声明弱引用。

弱引用.png

只放出不同部分： self.printer = { [weak self] in print("name: \(self!.name)") }

弱引用内存图.png

Weak-Strong Dance

这个有点儿诗意的名字是用来延长弱引用对象的生存周期的，别还没等到你要用，对象就被系统给咔嚓了。

Weak-Strong Dance.png

下面运用了一点多线程知识，不详讲了，总之你要明白在代码中弱引用是非常不安全的。在进行一系列操作时，可能等不到你要使用它，就被系统回收了它的内存。在本例中，注释部分就是临时转换成一个强引用局部变量，没有被注释的代码就是 withExtendedLifetime 函数了。

import UIKit
class Employee {
 var name: String
 init(name:String){
        self.name=name
        print("Employee init")
    }
func doClosure() {
        DispatchQueue.global().async { [weak self] in
        /*
            self?.process("first process")
            usleep(500)
            self?.process("second process")
            */
       /*
            if let strongRef=self {
                strongRef.process("first process")
                usleep(500)
                strongRef.process("second process")
            }*/
          withExtendedLifetime(self){
                self?.process(message: "first process")
                usleep(500)
                self?.process(message: "second process")
            }   
        }
    }
 deinit {
        print("Employee deinit")
    }
    func process(message: String) {
        print(message)
    }
}
var employee: Employee? = Employee(name:"Jason")
employee?.doClosure()
DispatchQueue.global().async {
    usleep(100)
    employee = nil
}
dispatchMain()
/* print :
Employee init
first process
second process
Employee deinit
*/

第三周作业

题目

请说出下面代码存在的问题，以及改进方式。
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

答案

一个简单的循环引用，不解释了。

class Customer {
    let name: String
    weak var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}
var xiaoMing: Customer?
var xiaoMingID: CreditCard?
xiaoMing = Customer(name: "xiaoMing")
xiaoMingID = CreditCard(number: 522644, customer: xiaoMing!)
xiaoMing?.card = xiaoMingID
xiaoMing = nil
xiaoMingID = nil