使用泛型好处：
泛型可以更好地、更抽象地扩大该方法的作用域。
泛型可以将类型参数化，提高代码复用率，减少代码量。
泛型在使用的时候要确定类型（要么自动推导出类型，要么指定类型）。
泛型的基础使用
泛型函数
使用泛型前：
func swapValuesInt(_ a: inout Int, _ b: inout Int) {
(a, b) = (b, a)
}
func swapValuesDouble(_ a: inout Double, _ b: inout Double) {
(a, b) = (b, a)
}
var i1 = 10
var i2 = 20
swapValuesInt(&i1, &i2)
var d1 = 10.0
var d2 = 20.0
swapValuesDouble(&d1, &d2)
print("i1 = \(i1), i2 = \(i2)")
print("d1 = \(d1), d2 = \(d2)")
输出
i1 = 20, i2 = 10
d1 = 20.0, d2 = 10.0
使用泛型后：
//泛型函数定义式
func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型
{
//函数体...
}
//定义一个交换函数，通过元组交换的，定义T为泛型
func swapValues<T>(_ a: inout T, _ b: inout T) {
(a, b) = (b, a)
}
var i1 = 10
var i2 = 20
swapValues(&i1, &i2)
var d1 = 10.0
var d2 = 20.0
swapValues(&d1, &d2)
print("swapValues - i1 = \(i1), i2 = \(i2)")
print("swapValues - d1 = \(d1), d2 = \(d2)")
输出：
swapValues - i1 = 20, i2 = 10
swapValues - d1 = 20.0, d2 = 10.0
直接调用时不需要传入泛型，比如不能swapValues< Int >，因为传入参数时就可以确定类型
将函数赋值给一个变量时：
//将函数赋给一个变量
let fn: (inout Int, inout Int) -> () = swapValues
var fn1 = 10
var fn2 = 20
fn(&fn1, &fn2)
print("fn1 = \(fn1), fn2 = \(fn2)")
输出：
fn1 = 20, fn2 = 10
泛型函数赋值给变量，要在：后面明确类型。
因为只是把泛型函数赋值给变量，等到调用函数的时候还是不知道函数的类型，所以要求泛型函数赋值给变量的时候要指定类型。
泛型类型
在定义类型时使用泛型。
使用和泛型函数差不多，就是在类型名后面加上<泛型1,泛型2,…>，然后在类型里面直接使用泛型即可
//定义一个泛型结构体，用于压栈和出栈，泛型类型可以使用到类、结构体、枚举等各种类型
struct Stack<T> {
//栈在这里是个数组存储形式，数组中存储的数据类型是泛型类型
var items = [T]()
//因为压栈会修改实例值，需要加上mutationg关键字
mutating func push(_ item: T) {
items.append(item)
}
//因为出栈会修改实例值，需要加上mutationg关键字
mutating func pop() -> T {
return items.removeLast()
}
func size() -> Int {
items.count
}
}
//创建一个字符串栈，栈里面存的是字符串
var stackOfStrings = Stack<String>()
stackOfStrings.push("one")
stackOfStrings.push("two")
stackOfStrings.push("three")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
//创建一个整型栈，栈里面存的是整型
var stackOfInt = Stack<Int>()
stackOfInt.push(22)
stackOfInt.push(42)
stackOfInt.push(48)
print("\(stackOfInt.pop()) 出栈，栈中还有items：\(stackOfInt.items)")
print("\(stackOfInt.pop()) 出栈，栈中还有items：\(stackOfInt.items)")
输出：
three 出栈, size = 2, 栈中还有items：["one", "two"]
two 出栈, size = 1, 栈中还有items：["one"]
one 出栈, size = 0, 栈中还有items：[]
48 出栈，栈中还有items：[22, 42]
42 出栈，栈中还有items：[22]
泛型枚举
enum Score<T> {
case result(T)
case grade(String)
}
let scoreGrade = Score<Int>.grade("100")
let scoreResult = Score<String>.result("Sucess")
switch scoreGrade {
case .result(let result):
print("reslut = \(result)")
case let .grade(string):
print("grade = \(string)")
}
switch scoreResult {
case .result(let result):
print("reslut = \(result)")
case let .grade(string):
print("grade = \(string)")
}
输出：
grade = 100
reslut = Sucess
使用时，需要明确类型，就算scoreGrade没有用到result也要指定
是因为枚举要确定内存结构。
关联类型
协议通过关联类型来实现泛型，不能像class/struct中那样实现。
关联类型可以给协议中用到的类型定义一个占位名称，使用关键字associatedtype来定义。
protocol Stackable {
//协议中使用泛型，用关联类型
associatedtype HFItem
mutating func push(_ item: HFItem)
mutating func pop() -> HFItem
func size() -> Int
}
struct HFStakck<T>: Stackable {
var items = [T]()
mutating func push(_ item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
func size() -> Int {
return items.count
}
}
var stackOfStrings = HFStakck<String>()
stackOfStrings.push("hello")
stackOfStrings.push("bye")
stackOfStrings.push("good")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
print("\(stackOfStrings.pop()) 出栈, size = \(stackOfStrings.size()), 栈中还有items：\(stackOfStrings.items)")
//创建一个整型栈，栈里面存的是整型
var stackOfInt = HFStakck<Int>()
stackOfInt.push(32)
stackOfInt.push(52)
stackOfInt.push(98)
print("\(stackOfInt.pop()) 出栈，栈中还有items：\(stackOfInt.items)")
print("\(stackOfInt.pop()) 出栈，栈中还有items：\(stackOfInt.items)")
输出：
good 出栈, size = 2, 栈中还有items：["hello", "bye"]
bye 出栈, size = 1, 栈中还有items：["hello"]
hello 出栈, size = 0, 栈中还有items：[]
98 出栈，栈中还有items：[32, 52]
52 出栈，栈中还有items：[32]
泛型约束
泛型约束大致分为以下几种：
继承约束，泛型类型必须是某个类的子类类型
协议约束，泛型类型必须遵循某些协议
条件约束，泛型类型必须满足某种条件
//继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
//函数体，泛型类型是某个类的子类类型
}
//协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
//函数体，泛型类型遵循某些协议
}
//条件约束使用格式
func 函数名<泛型1, 泛型2 where 条件>(参数列表) -> 返回值 {
//函数体，泛型类型满足某些条件
}
继承约束
class HFAnimal {
func run() {
print("Animal run")
}
}
class HFDog: HFAnimal {
override func run() {
print("Dog run")
}
}
class HFCat: HFAnimal {
override func run() {
print("Cat run")
}
}
// 定义泛型函数，接受一个泛型参数，要求该泛型类型必须继承Animal
func hfAnimalRun<T: HFAnimal>(_ animal: T) {
animal.run()
}
hfAnimalRun(HFDog())
hfAnimalRun(HFCat())
hfAnimalRun(HFAnimal())
输出：
Dog run
Cat run
Animal run
协议约束
protocol Stackable {
//协议中使用泛型，用关联类型
associatedtype Item
mutating func push(_ item: Item)
mutating func pop() -> Item
func size() -> Int
}
/*
约束如下：
1. S1、S2 都是泛型，
2. 泛型都遵守协议Stackable
3. S1和S2的关联类型要相等，这个Item是在类Stack中赋值的，他们要赋值相同
4. S1的关联类型必须遵守Hashable协议
通过where可以增加类型的约束
*/
func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool
where S1.Item == S2.Item, S1.Item : Hashable {
// 如果两个栈的元素个数不同，它们不可能相等
guard s1.size() == s2.size() else {
return false
}
// 创建临时变量保存栈的副本，以免修改原始栈
var stack1 = s1
var stack2 = s2
// 逐个比较栈中的元素
while stack1.size() > 0 {
// 如果栈顶元素不相等，栈就不相等
if stack1.pop() != stack2.pop() {
return false
}
}
// 如果所有元素都相等，则栈相等
return true
}
struct HFStakck<T>: Stackable {
var items = [T]()
mutating func push(_ item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
func size() -> Int {
return items.count
}
}
var hfStack1 = HFStakck<Int>()
var hfStack2 = HFStakck<Int>()
var hfStack3 = HFStakck<Int>()
hfStack3.push(23)
print("hfStack1 == hfStack2 = \(equal(hfStack1, hfStack2)) \n hfStack1 == hfStack3 = \(equal(hfStack1, hfStack3))")
输出：
hfStack1 == hfStack2 = true
hfStack1 == hfStack3 = false
若如下图：
因为设置类型不一致，所以不能继续校验
