swift 泛型

泛型是为Swift编程灵活性的一种语法，在函数、枚举、结构体、类中都得到充分的应用，它的引入可以起到占位符的作用，当类型暂时不确定的，只有等到调用函数时才能确定具体类型的时候可以引入泛型

泛型可以理解为：泛型就是占位符

泛型函数

• 函数的泛型使用了占位类型名（在这里用字母 T 来表示）来代替实际类型名（例如 Int、String）。占位类型名没有指明 T 必须是什么类型，但是它指明了 a 和 b 必须是同一类型 T，无论 T 代表什么类型。只有 swapTwoValues(::) 函数在调用时，才会根据所传入的实际类型决定 T 所代表的类型。
• 泛型函数和非泛型函数的另外一个不同之处，在于这个泛型函数名（swapTwoValues(::)）后面跟着占位类型名（T），并用尖括号括起来（<T>）。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T 的实际类型

//非泛型函数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoStrings(_ a: inout String, _ b: inout String) {
    let temporaryA = a
    a = b
    b = temporaryA
}

//泛型函数
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

类型参数

• 类型参数指定并命名一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（例如 <T>）
• 多个类型参数，将它们都写在尖括号中，用逗号分开
• 命名类型参数：通常使用单个字母来命名
• 始终使用大写字母开头的驼峰命名法（例如 T 和 MyTypeParameter）来为类型参数命名，以表明它们是占位类型，而不是一个值

类型约束

• 类型约束可以指定一个类型参数必须继承自指定类，或者符合一个特定的协议或协议组合
• 在一个类型参数名后面放置一个类名或者协议名，并用冒号进行分隔，来定义类型约束，它们将成为类型参数列表的一部分

第一个类型参数A，A必须是ClassA子类的类型约束
第二个类型参数B，B必须符合ClassB协议的类型约束
func doSomething<A:ClassA,B:ClassB>(someA:A someB:B){
    
}

关联类型

• 关联类型为协议中的某个类型提供了一个占位名,代表的实际类型在协议被采纳时才会被指定
• 通过 associatedtype 关键字来指定关联类型

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

这个协议没有指定元素必须是何种类型，为了满足这三个条件，Container 协议需要在不知道容器中元素的具体类型的情况下引用这种类型。Container 协议需要指定任何通过 append(_:) 方法添加到容器中的元素和容器中的元素是相同类型，并且通过容器下标返回的元素的类型也是这种类型，为了达到这个目的，Container 协议声明了一个关联类型 ItemType，写作 associatedtype ItemType。这个协议无法定义 ItemType 是什么类型的别名，这个信息将留给遵从协议的类型来提供

struct Stack<Element>: Container {
    // Stack<Element> 的原始实现部分
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // Container 协议的实现部分
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

泛型 where 语句

下面这个泛型函数在类型参数里面添加了where子句约束，C1,C2都必须是采纳Container协议的类型，并且C1、C2的泛型类型必须相同，而且C1的泛型类型必须是符合Equatable的

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

func allItemsMatch<C1:Container,C2:Container where C1.itemType == C2.itemType,C1.itemType:Equatable>(someContainer:C1,_ anotherContainer:C2) -> Bool{
    if someContainer.count != anotherContainer.count{
        return false
    }
    
    for i in 0...someContainer.count-1{
        if someContainer[i] != anotherContainer[i]{
            return false
        }
    }
    return true
}