泛型（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也就是元类型来实现的
- 泛型函数赋值给变量，也是可以说赋值给参数
- 泛型的举例应用：
- 类的泛型
类泛型的继承：
记住要写泛型<E>
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协议，不知道它的具体类型，更不知道具体类型的属性和方法。