泛型
- 泛型函数
泛型函数和非泛型函数的不同之处在于：
泛型函数名（swapTwoValues(::)）后面跟着 占位类型名（T），并用 尖括号 括起来（<T>）。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T的实际类型
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}
- 泛型协议
/// 1、定义泛型协议
protocol LFStackProtocol {
// associatedtype：声明关联类型（占位符）
associatedtype LFStack
mutating func pushValue(value: LFStack)
mutating func popValue() -> LFStack
}
/// 泛型协议 类型 条件约束
extension LFStackProtocol where LFStack == String {}
- 泛型类型
/// 2、泛型结构体
struct LFStack<Element> {
// 泛型属性
var stacks: [Element] = [Element]()
}
extension LFStack: LFStackProtocol {
// typealias：设置关联类型
typealias LFStack = Element
mutating func pushValue(value: Element) {
stacks.append(value)
}
mutating func popValue() -> Element {
stacks.removeLast()
}
}
extension LFStack {
var topValue: Element? {
return self.stacks.isEmpty ? nil : self.stacks[self.stacks.count - 1]
}
/// 3、泛型函数
func changeValue<Element>(value1: inout Element, value2: inout Element) {
let tempVale = value1
value1 = value2
value2 = tempVale
debugPrint("value1 = \(value1) --- value2 = \(value2)")
}
/// 4、泛型 协议约束
func findIndex<Element: Equatable>(elements: [Element], element: Element) -> Int? {
var index = 0
for e in elements {
// 因为遵循了Equatable协议，所以可以进行相等比较
if e == element {
return index
} else {
index += 1
}
}
return nil
}
}
用法：
class TestLFStack: NSObject {
class func testLFStack() {
var lfStack = LFStack<String>()
lfStack.pushValue(value: "haha")
debugPrint("popValue = \(lfStack.popValue())")
var value1 = 11
var value2 = 12
lfStack.changeValue(value1: &value1, value2: &value2)
}
}
- 泛型约束
- 继承约束：必须 是某个类的子类类型
- 协议约束：必须 遵循某些协议
- 条件约束：必须 满足某种条件
// 继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
// 函数体，泛型类型是某个类的子类类型
}
// 协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
// 函数体，泛型类型遵循某些协议
}
// 条件约束使用格式
func 函数名<泛型1, 泛型2 where 条件>(参数列表) -> 返回值 {
// 函数体，泛型类型满足某些条件
}
