Swift泛型Generics浅析讲解 Swift泛型Generics浅析讲解

泛型（Generics）
汇编分析泛型的实现原理
关联类型（Associated Type）
类型约束
协议类型的注意点
泛型解决
不透明类型（Opaque Type）

泛型（Generics） 1、泛型可以将类型参数化，提高代码复用率，减少代码量

func swapValue(_ a: inout T, _ b: inout T) -> Void {(a, b) = (b, a)}

var fn: (inout Int, inout Int) -> () = swapValue

栈

class Stack {var elements = [E]()func push(_ element: E) -> Void {elements.append(element)}func pop() -> E {elements.removeLast()}func top() -> E {elements.last!}func size() -> Int {elements.count}}var intStack = Stack()var stringStack = Stack()var anyStack = Stack()

class SubStack: Stack {}struct Stack {var elements = [E]()mutating func push(_ element: E) {elements.append(element)}mutating func pop() -> E {elements.removeLast()}func top() -> E {elements.last!}func size() -> Int {elements.count}}

汇编分析泛型的实现原理

文章图片

文章图片

通过汇编我们可以看到两次调用的swapValues方法的地址是相同的，也就是说是相同的方法，汇编中有关于metadata的信息，所以推测Swift中的泛型是通过对元数据的处理实现的。

关联类型（Associated Type） 1、关联类型的作用：给协议中用到的类型定义一个占位名称
2、协议中可以拥有多个关联类型

protocol Stackable {associatedtype Elementmutating func push(_ element: Element)mutating func pop() -> Elementfunc top() -> Elementfunc size() -> Int}

class StringStack: Stackable {//typealias Element = String 可写可不写var elements = [String]()func push(_ element: String) -> Void {elements.append(element)}func pop() -> String {elements.removeLast()}func top() -> String {elements.last!}func size() -> Int {elements.count}}

【Swift泛型Generics浅析讲解】
类型约束

protocol Runnable {}class Person {}func swapValues(_ a: inout T, _ b: inout T) -> Void {(a, b) = (b, a)}

更多的约束

func equal(_ s1: S1, _ s2: S2) -> Boolwhere S1.Element == S2.Element, S1.Element: Hashable{return false}

协议类型的注意点

protocol Runnable {}class Person: Runnable {}class Car: Runnable {}func getObject(_ type: Int) -> Runnable {if type == 0 {return Person()}return Car()}var r1 = getObject(0)var r2 = getObject(1)

1、如果协议中有associatedtype，那么会有类型识别不了的问题，以下代码会报错

protocol Runnable {associatedtype Speedvar speed: Speed {get}}class Person: Runnable {var speed: Double {0.0}}class Car: Runnable {var speed: Int {0}}func getObject(_ type: Int) -> Runnable {if type == 0 {return Person()}return Car()}

泛型解决解决方案1：使用泛型

protocol Runnable {associatedtype Speedvar speed: Speed {get}}class Person: Runnable {var speed: Double {0.0}}class Car: Runnable {var speed: Int {0}}func getObject(_ type: Int) -> T {if type == 0 {return Person() as! T}return Car() as! T}var r1: Person = getObject(0)var r2: Car = getObject(1)

不透明类型（Opaque Type） 1、解决方案2：使用some关键字声明一个不透明类型