Swift：泛型

泛型

1. 泛型函数
   泛型函数和非泛型函数的不同之处在于：
   泛型函数名（swapTwoValues(::)）后面跟着 占位类型名（T），并用 尖括号 括起来（）。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名，因此 Swift 不会去查找名为 T的实际类型

func swapTwoValues(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

2. 泛型协议

/// 1、定义泛型协议
protocol LFStackProtocol {
    // associatedtype：声明关联类型（占位符）
    associatedtype LFStack
    mutating func pushValue(value: LFStack)
    mutating func popValue() -> LFStack
}

/// 泛型协议 类型 条件约束
extension LFStackProtocol where LFStack == String {}

3. 泛型类型

/// 2、泛型结构体
struct LFStack {
    // 泛型属性
    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(value1: inout Element, value2: inout Element) {
        let tempVale = value1
        value1 = value2
        value2 = tempVale
        debugPrint("value1 = \(value1) --- value2 = \(value2)")
    }
    
    /// 4、泛型 协议约束
    func findIndex(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()
        lfStack.pushValue(value: "haha")
        debugPrint("popValue = \(lfStack.popValue())")

        var value1 = 11
        var value2 = 12
        lfStack.changeValue(value1: &value1, value2: &value2)

    }  
}

4. 泛型约束

• 继承约束：必须 是某个类的子类类型
• 协议约束：必须 遵循某些协议
• 条件约束：必须 满足某种条件

// 继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
      // 函数体，泛型类型是某个类的子类类型
}

// 协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
      // 函数体，泛型类型遵循某些协议
}

// 条件约束使用格式
func 函数名<泛型1, 泛型2 where 条件>(参数列表) -> 返回值 {
      // 函数体，泛型类型满足某些条件
}

泛型用法