[Swift]泛型

1. Swift泛型的定义方法：

    1) 和C++泛型概念一样，用法和C++也相似，同样也是使用一个类型占位符（代表一个通用类型，也是泛型的参数，用户随意取名，但要求按照标示符命名规则进行，因为其代表一个通用类型，因此和定义其它类型名的规范一样，最好是首字母大写的驼峰命名方式，一般取T）；

    2) 一个简单的泛型函数的例子：

func mySwap<T>(inout a: T, inout b: T) {
    let t = a
    a = b
    b = t
}

var a = 1, b = 2
mySwap(&a, &b)
println(a) // 2
println(b) // 1

// Swift自己的库也含有swap泛型函数
swap(&a, &b) // 又换回来了
println(a) // 1
println(b) // 2

func myEqual<T: Comparable>(a: T, b: T) -> Bool {
    return a == b
}

此例子中类型占位符为T，可以当做普通类型一样使用；

    3) 和任何一种语言的泛型一样，都是动态推导类型的，只有当实际传参的时候才会根据参数类型生成相应版本的代码（即运行时动态加载函数代码），因此执行效率较低，但是程序灵活性非常强；

    4) 多类型参数：如果有多个类型占位符，则声明的时候用逗号,隔开

func f<T, K>(a: T, b: K) -> K {
    return b
}

println(f(12, "haha")) // haha

2. 泛型模板类以及扩展模板类：

    1) 和C++模板类的概念一致，在类定义中可以含有类型占位符，用于表示一种通用类型；

！！泛型不仅支持函数，同时也支持结构体和枚举类型！

    2) 定义类模板是需要在类名之后写上占位符，请看如下例子，模拟实现一个栈模板类：

struct Stack<T> {
    var items = [T]()
    
    mutating func push(item: T) {
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
}

     3) 扩展模板类时不需要重新写泛型参数列表，可以在扩展体中直接使用定义类时的泛型，非常方便：接上例代码

extension Stack {
    subscript(index: Int) -> T? {
        if index < 0 || index + 1 > countElements(items) {
            return nil
        }
        
        return items[index]
    }
}

3. 泛型约束：

    1) 顾名思义，就是要求那个类型占位符所代表的泛型遵守某些规矩，比如必须要遵守某些协议，或者必须由什么类继承而来等；

    2) 实际上只能约束泛型遵守什么协议或者泛型继承自那个类，比如对于比较两个泛型是否内容相等，就不能直接使用普通的泛型，必须使用能遵守Equatable协议的两个泛型才能比较，该协议规定类型必须实现==和!=两种操作符的实现，可以想象，如果不遵守该协议，直接在泛型函数体中使用==操作符比较两个泛型是否相等，如果该泛型传进来的是一个用户自定义的类并且该类没有实现==操作符，那该如何让该泛型函数进行比较呢？请看以下的例子：

func equals<T: Equatable>(a: T, b: T) -> Bool {
    return a == b
}

如果要求遵守多个协议则用逗号隔开，就和继承类、遵守协议的语法一模一样，比如：

func equals<T: Equatable, Hashable>(a: T, b: T) -> Bool { // 既遵守Equatable协议也遵守Hashable协议
    return a == b
}

    3) 再来看一个例子，该例子是在一个泛型数组中查找某个元素并返回下标：

func findItemIndexFrom<T: Equatable>(arr: [T], byValue val: T) -> Int? {
    for (index, value) in enumerate(arr) {
        if value == val {
            return index
        }
    }
    
    return nil
}

4. 关联类型——实现“泛型协议”：

    1) Swift不运行定义泛型协议（至少语法上不允许像定义泛型类型那样定义泛型协议），但是有时有这方面的需要，比如在一个协议中指定一种泛型，然后协议中规定了很多方法或属性都需要用到该泛型，但一个类遵守该协议时再根据具体需要规定该泛型的具体类型，同时并使用该具体类型来实现协议中规定的方法和属性；

    2) 答案时肯定的，Swift提供关联类型这种形式来解决以上问题，即可以先用typealias定义一个泛型（即不对该泛型赋值，值定义其名字），然后在规定要实现的属性或方法中使用该泛型，最后是当一个类型遵守该协议时再用typealias对该泛型进行赋值，使其成为某个具体的类型，接着再实现规定的属性和方法时用具体的类型替换该泛型即可：

protocol A {
    typealias ItemType // 先指定一个泛型
    
    // 规定要实现的内容中暂时用泛型替代
    mutating func push(item: ItemType)
    mutating func pop() -> ItemType
}

struct Stack<T>: A {
    var items = [T]()
    
    // 遵守协议时再将泛型和某种具体的类型“相关联”，而该某种具体的类型可以是模板类的类型占位符！
    // 可见Swift超级强大
    typealias ItemType = T // 同样是可写可不写，编译器能自动推断
    mutating func push(item: T) { // 实现时用具体类型代替关联类型
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
}

struct IntStack: A { // 一个Int的版本
    var items = [Int]()
    
    typealias ItemType = Int // 词句可写可不写，编译器都能自动推断
    mutating func push(item: Int) {
        items.append(item)
    }
    
    mutating func pop() -> Int {
        return items.removeLast()
    }
}

5. 用where语句对关联类型进行约束：

    1) 和SQL的where约束类似，该约束发生在指定某个类型遵守某个协议（协议带有关联类型）时使用；

    2) 具体语法如下：

protocol ProtocolStack {
    typealias ItemType
    
    mutating func push(item: ItemType)
    mutating func pop() -> ItemType
    var count: Int { get }
    subscript(index: Int) -> ItemType { get }
}

struct Stack<T>: ProtocolStack {
    var items = [T]()
    
    mutating func push(item: T) {
        items.append(item)
    }
    
    mutating func pop() -> T {
        return items.removeLast()
    }
    
    var count: Int { return countElements(items) }
    
    subscript(index: Int) -> T {
        return items[index]
    }
}

func isAllItemMatched<
    STK1: ProtocolStack, STK2: ProtocolStack
    where STK1.ItemType == STK2.ItemType, STK1.ItemType: Equatable
    >(stk1: STK1, stk2: STK2) -> Bool {
        // 该函数用于比较两个栈中的内容是否完全相等
        // 因此两个类型都必须遵守ProtocolStack协议
        // 并且栈中元素必须遵守可比较协议Equatable
        // 元素进行比较的前提是两种栈中元素的类型必须相同，这也就是要求两种关联类型必须相同
        
    if ( stk1.count != stk2.count ) {
        return false
    }
    
    for i in 0..<stk1.count {
        if stk1[i] != stk2[i] {
            return false
        }
    }
    
    return true
}

    3) 对以上成果进行使用：泛型类型定义方法和C++类似，如下

var stk1 = Stack<Int>()
var stk2 = Stack<Int>()

for i in 0..<10 {
    stk1.push(i)
    stk2.push(i)
}

println(isAllItemMatched(stk1, stk2)) // true