- 泛型可以将类型参数化,提高代码复用率,减少代码量
func swapValues<T>(_ a: inout T, _ b: inout T) {
(a, b) = (b, a)
}
var n1 = 10
var n2 = 20
swapValue(&n1, &n2)
- 泛型函数赋值给变量
var fn:(inout: Int, inout: Int) -> () = swapValues
fn(&n1, &n2)
var test<T1, T2>(_ t1: T1, _ t2: T2) {}
var fn: (Int, Double) -> () = test
- 类泛型
class Stack<E> {
var elements = [E]()
func push(_ element: E) { elements.append(element) }
func pop() -> E { elements.removeLast() }
func top() -> E { elements.last! }
func size() -> Int { elements.count }
}
var stack = Stack<Int>()
class SubStack<E> : Stack<E> {}
- 结构体泛型
struct Stack<E> {
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 }
}
- 枚举泛型
enum Score<T> {
case point<T>
case grade(String)
}
let score0 = Score<Int>.point(100)
let score1 = Score.point(99)
let score2 = Score.point(99.5)
let score3 = Score<Int>.grade("A") //必须初始化泛型类型
关联类型Associated Type
- 关联类型的作用:给协议中用到的类型定义一个占位名称
- 协议中可以拥有多个关联类型
protocol Stackable {
associatedtype Element //关联类型
//associatedtype Element2 //关联类型
mutating func push(_ element: Element)
mutating func pop() -> Element
func top() -> Element
func size() -> Int
}
class StringStack : Stackable {
//给关联类型设定真实类型
//typealias Element = String
var elements = [String]()
func push(_ element: String) { elements.append(element) }
func pop() -> String { elements.removeLast() }
func top() -> String { elements.last! }
func size() -> Int { elements.count }
}
类型约束:
protocol Stackable {
associatedtype : Equatable
}
class Stack<E: Equatable> : Stackable {
typealias Element = E
}
func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> BOOl
where S1.Element == S2.Element, S1.Element : Hashable {
return false
}
协议类型的注意点:
- 关联类型不能直接作为返回值
protocol Runnable {
associatedtype Speed
var speed: Speed { get }
}
class Person : Runnable {
var speed: Double { 0.0 }
}
class Car : Runnable {
var speed: Int { 0 }
func run() {}
}
解决方案1
func get<T: Runnable>(_ type: Int) -> T {
if type == 0 {
return Student() as! T
}
return Person() as! T
}
var r1 = get(0)
var r1 = get(1)
解决方案2
不透明类型,只能返回一种类型,屏蔽具体类型,只暴露协议类型
func get(_ type: Int) -> some Runable {
//if type == 0 {
// return Student()
//}
return Person()
}
var r1 = get(0)
r1.speed //Runable.Speed
//ri.run() 不能调用
- some除了用在返回值类型上,一般还可以用在属性类型上
protocol Runnable { associatedtype Speed }
class Dog : Runnable { typealias Speed = Double }
class Person {
var pet: some Runnable {
return Dog()
}
}
- 或者 下面这种也是一种看不到真实类型的方式
protocol Runnable { }
class Dog : Runnable { }
class Person {
var pet: Runnable {
return Dog()
}
}