泛型 - 简书

泛型

1.为什么要有泛型?
2.泛型有什么好处?
3.Swift泛型语法
4.泛型的使用

为什么要有泛型

在编程世界中,我们经常遇到的问题有实现一个交换两个变量的方法,或者实现一个集合类型来储存相同类型的变量.
对于情况1,我们可能需要声明多个函数实现,用于交换变量来适应不同的数据类型,比如Int,Float,Double.但是其实我们发现,多数情况下交换两个变量的代码逻辑是一致的.每一种类型都需要实现一个函数是不是有点繁杂冗余呢?

//Int
func swap(lhs: inout Int,rhs: inout Int){
    lhs = lhs + rhs
    rhs = lhs - rhs
    lhs = lhs - rhs
}
//Float
func swap(lhs: inout float,rhs: inout Float){
    (lhs,rhs) = (rhs,lhs)
}
.....

对于情况2,假如我们想要实现一个Struct来抽象一个盒子,用于储存其它类型,但是存储的东西肯定是多种多样的,一个数字,或者水果等等.那么我们就要声明多个类型的盒子,来满足这样的需求.

泛型有什么好处?

当然了,程序的存在就是为了简化操作,去除重复的内容-那么就因此引入了泛型的概念.
泛型(Generic)可以让你写出根据自我需求定义,适应于任何类型的,灵活且可重用的函数和类型,可以让你避免重复的代码,用一种清晰和抽象的方式来表达代码的意图.其实,泛型早已是高级编程语言的标配,比如C++的Template,Java,C#等都具有泛型的概念.
有了泛型,对于上面的情况,我们只需要实现一个方法,实现一个Struct就可以实现,是不是很奇妙.
泛型给我们提供了一种更为抽象的编程模型，使得能更专注于业务模型以及算法本身。

func swap<T>(lhs:inout T,rhs: inout T){
    let temp = lhs
    lhs = rhs
    rhs = temp
}

Swift的泛型语法

在swift中,有许多泛型函数比如swap,集合类型基本上都是泛型结构实现的.

let array:[Int] = [1,23,44]
let dict:[String:Any] = Dictionary<String,Any>(dictionaryLiteral: ("name","sum"),("age",20),("sex",true))

我们可以在以下地方使用泛型

Function
Struct/Enum/Class
Protocol(其实是关联类型)
Extesion

对函数和类型使用泛型，我们只需在函数或类型标识符后跟 <>，里面放泛型形参列表,表示占位类型.编译器用实际类型替换占位类型的过程称为特化(specialization),特化能让编译器把应用变得更快,因为编译器能产生知道实际使用的类型是什么的代码.

struct Box<T>{
    var content:T
    mutating func change(content:T){
        self.content = content
    }
}

T可用于各个地方，比如用于定义属性，用于定义方法的形参类型乃至方法的返回类型等都可以。当然你也可以使用其它标签名字,使用更多的泛型参数

在协议中不可以使用泛型,但是协议支持关联类型(associated types),来达到泛型同样的效果

protocol Animal {
    associatedtype Class
    var type:Class { get }
}

struct Cat:Animal {
    typealias Class = String
    var type: String{
        return "Cat"
    }
}

如果协议有关联类型，那么这个协议就不能用作具体类型。举个例子，不能声明一个IteratorProtocol 类型的变量，也不能声明一个参数类型是IteratorProtocol 的函数.因为含有关联类型或Self类型的协议必须经过深层的类型推导外加类型检查，不同类型对此类协议的遵循可能会有各种不同的实现方式，涉及到的面会更广，所以使用泛型反而能获得更好的优化。

//Protocol 'Animal' can only be used as a generic constraint because it has Self or associated type requirements
let s:Animal = Cat()

泛型约束

使用泛型时,在默认情况下我们对将要使用的具体类型一无所知,造成的一个实际影响就是我们对于具体类型的值能做的事情很少。只能使用赋值操作符 = 对泛型类型的对象进行操作，而不能使用其他操作.因此引入了类型约束(Type Constraints）的概念,来对泛型类型作出一定的假设,以此增强泛型的灵活性.泛型约束<T:XXX>用于说明当前泛型类型必须遵循哪些协议，或者继承自哪个类。

func foo<T:Comparable>(a:T,b:T,c:T) -> T{
    var mins = min(a, b)
    mins = min(mins,c)
    return mins
    }

等同于

func foo<T>(a:T,b:T,c:T) -> T where T:Comparable{
    var mins = min(a, b)
    mins = min(mins,c)
    return mins
    }

where从句约束

where从句对类型的限定只能使用 : 以及 == 这两种操作符。: 表示将该泛型约束为冒号后面类类型的子类或遵循后面的协议组合(&)。== 则表示泛型必须与 == 后面的类型完全一致，也就是说如果 == 后面是某个协议类型，那么该泛型实参必须是该协议类型；如果是一个类类型，那么该泛型也必须是那个类类型。
当where从句用于泛型时，必须放在类型声明或函数声明的后面，左花括号 { 的前面。

struct Zone<T:Animal> where T.Class:Comparable&Hashable {
    // .....
}