泛型（Generics）

• 泛型可以将类型参数化，提高代码复用率，减少代码量

func swapValues<T>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

var i1 = 10
var i2 = 20
swapValues(&i1, &i2)
print(i1, i2) // 20, 10 i1和i2的值交换了

var d1 = 10.0
var d2 = 20.0
swapValues(&d1, &d2)
print(d1, d2) //20.0, 10.0 d1和d2的值交换了

struct Date {
    var year = 0, month = 0, day = 0
}
var dd1 = Date(year: 2011, month: 9, day: 10)
var dd2 = Date(year: 2012, month: 10, day: 11)
swapValues(&dd1, &dd2)
print(dd1,dd2)//Date(year: 2012, month: 10, day: 11), Date(year: 2011, month: 9, day: 10)  dd1和dd2的值交换了

通过反汇编看一下上面的泛型交换值函数的额原理：

T为Int：

T为Double：

可以看出，虽然泛型的类型不同，但是可以看出两个函数的地址都是0x100001800，调用的同一个函数，可以区分不同类型进行计算，只要是靠metadata也就是元类型来实现的

• 泛型函数赋值给变量，也是可以说赋值给参数

• 泛型的举例应用：

1. 类的泛型

类泛型的继承：

 记住要写泛型<E>

扫描二维码关注公众号，回复： 14575033 查看本文章

 2.   结构体的泛型

因为push会添加元素到数组，pop会删除元素从数组，都会改变内存，所以要加mutating

Score<Int>.grade("A")需要加Int是因为初始化时就要告诉泛型的类型，即使你没调用泛型

---

关联类型

• 关联类型的作用：给协议中用到的类型定义一个占位名称
• 协议中可以拥有多个关联类型

  使用typealias给关联类型设置真实类型可以省略，因为会根据你传入的参数类型自动识别

  也可以传入一个泛型来代替关联类型

---

类型约束

针对泛型的类型约束：

protocol Runnable {
    
}

class Person {
    
}

//要求传入的泛型既是Person或Person 的子类，又要遵守Runnable协议
func swapValues<T: Person & Runnable>(_ a: inout T, _ b: inout T) {
    (a, b) = (b, a)
}

针对关联类型的约束：关联类型遵守Equatable协议，泛型也要遵守相同的协议：

protocol Stackable {
    associatedtype Element: Equatable
}

class Stack<E: Equatable> : Stackable {typealias Element = E}

多个泛型结合where的复杂约束：

S1和S2两个泛型都遵守Stackable协议，并且S1和S2的Element属于同一类型，S1的Element遵守Hashable协议

func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool where S1.Element == S2.Element, S1.Element : Hashable{
    return true
}

var stack1 = Stack<Int>()
var stack2 = Stack<Int>()
var isEqual = equal(stack1, stack2)
print(isEqual) //true

但是当stack1和stack2的泛型类型不一致会报错：

---

协议类型的注意点

protocol Runnable { }
class Person: Runnable { }
class Car: Runnable { }

func get(_ type: Int) -> Runnable {
    if type == 0 {
        return Person()
    }
    return Car()
}

var r1 = get(0)
var r2 = get(1)
print(r1, r2) //TestSwift.Person TestSwift.Car

由上面的方法可知，get方法需要返回一个遵守Runnable 协议的值，而Person和Car正好都遵守Runnable 协议，所以正确

• 如果协议中有associatedtype

具体报的错误：

报错的原因是这种写法，编译器在编译时期不能确定associatedtype(关联类型)的值

顺便说一句，作为参数会有同样的错误：

---

协议类型错误的解决方案

1.   使用泛型解决

func get<T : Runnable>(_ type: Int) -> T {
    if type == 0 {
        return Person() as! T
    }
    return Car() as! T
}

var r1: Person = get(0)
var r2: Car = get(1)

成功原因：这种情况下，我们就明确了get(0)的返回值是Person类型，get(1)的返回值是Car类型，这样在编译时期就可以知道相对应的associatedtype(关联类型)的值，所以正确

但是这种写法存在风险，如果你把代码写成var r1:Car = get(0)，这样当走入get方法时代码就会变为Person as！Car，这样把Person类型强制转换为Car类型，就会报错的

2.  使用some关键字声明一个不透明类型，不透明类型就是some修饰的返回值只知道是遵守Runnable协议的，具体是什么类型不知道，实际类型的信息更不知道，并且some会强制只有一个返回值类型

这种写法限制了只返回一种类型，这样编译器就会知道返回值类型，从而知道associatedtype(关联类型)的值，所以正确

---

some

• some限制只能返回一种类型

• some除了用在返回值类型上，一般还可以用在属性类型上

这时的属性只知道遵守Runnable协议，不知道它的具体类型，更不知道具体类型的属性和方法。