Swift 中的泛型

Swift 泛型

• 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，这种参数类型可以用在类型、函数、和方法中
• 泛型能够让开发者编写自定义需求已经任意类型的灵活可用的的函数和类型。能够让我们避免重复的代码。用一种清晰和抽象的方式来表达代码的意图

泛型函数

定义一个交换两个值得泛型函数

func swapTwoValues<T>(_ a : inout T, _ b : inout T){    let temp = a    a = b    b = temp}var num1 = 11var num2 = 22swapTwoValues(&num1, &num2)print("num1: \(num1) -- num2: \(num2)")var str1 = "11"var str2 = "22"swapTwoValues(&str1, &str2)print("str1: \(str1) -- str2: \(str2)")

泛型类型

//定义一个泛型的栈

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

扩展泛型类型

extension Stack {    var topItem : Element? {        return items.isEmpty ? nil : items[items.count - 1]    }}var s = Stack<String>()s.push("1");print(s.topItem!)

类型约束

• 默认情况下，泛型函数和泛型类型可以作用于任何类型，不过，有的时候需要对泛型=函数和泛型类型中的类型做一些强制约束

• 类型约束可以指定一个类型参数必须继承自指定的类，或者符合一个特定协议或协议组合。可以在一个类型参数名后面放置一个类名或者协议名，通过冒号分割，从而定义类型约束。它们将作为类型参数列表的一部分

示例

 func 函数名<T:类名,U:协议名>(参数名称:T,参数名称2:U) {     //泛型函数的函数体部分 }

上述函数定义了有两个类型参数，第一个类型参数 T ,有一个T必须是某个类型的类型约束，第二个类型参数U,有一个U 必须符合某个协议的类型约束

关联类型

• 在定义协议时，有时候需要对对协议遵守者的元素类型有要求，此时可以在协议内声明一个或者多个关联类型，关联类型可以理解为协议的泛型类型，关联类型提供了一个占位名
  ，其代表的实际类型在协议被采纳时才会被指定， 通过 associatedtype 关键字来指定关联类型

protocol Container {    associatedtype itemType    mutating func append(_ item : itemType)    // 获取容器中元素的数    var count: Int { get }    // 通过索引值类型为 Int 的下标检索到容器中的每一个元素    subscript(i: Int) -> itemType { get }}

struct Stack2<Element> : Container{    var items = [Element]()    mutating func push(_ item : Element){        items.append(item)    }    mutating func pop() -> Element {        return items.removeLast()    }    mutating func append(_ item: Element) {        self.push(item)    }    var count: Int {        return self.items.count    }    subscript(i: Int) -> Element {        return items[i]    }}

where 子语句

• 为关联类型定义约束的方法就是在参数列表中添加 where 子句
• 作用：where 子句能够使一个关联类型符合某个协议，或者要求某个类型参数必须与关联类型的类型相同 where 子句紧跟在类型参数列表后面

func allItemsMatch< C1: Container, C2: Container>(_ someContainer: C1,_ anotherContainer: C2) -> Bool where C1.itemType == C2.itemType, C1.itemType: Equatable {        if someContainer.count != anotherContainer.count {            return false        }        for i in 0..<someContainer.count {            if someContainer[i] != anotherContainer[i] {                return false            }        }       return true}var stackOfStrings = Stack2<String>()stackOfStrings.push("uno")stackOfStrings.push("dos")stackOfStrings.push("tres")var arrayOfStrings = Stack2<String>()arrayOfStrings.push("uno")arrayOfStrings.push("dos")arrayOfStrings.push("tres")if allItemsMatch(stackOfStrings, arrayOfStrings) {    print("所有元素匹配")} else {    print("所有元素不能匹配")}