Swift 学习笔记 「泛型」

#Program

###泛型函数

func swapTwoInts(inout a: Int, inout b: Int)
  let temporaryA = a
  a = b
  b = temporaryA
}

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

###类型参数

在上面的 swapTwoValues 例子中,占位类型 T 是一种类型参数的示例。

###泛型类型

struct Stack<T> {
    var items = T[]()
    mutating func push(item: T) {
        items.append(item)
    }
    mutating func pop() -> T {
        return items.removeLast()
    }
}

###类型约束

  • 类型约束语法

      func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
      	// function body goes here
      }
    
  • 类型约束行为

      func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
          for (index, value) in enumerate(array) {
              if value == valueToFind {
                  return index	
              }
          }
          return nil
      }
    

###关联类型

protocol Container {
    typealias ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

使用 typealias 关键字来指定关联类型

###Where 语句

func allItemsMatch<
    C1: Container, C2: Container
    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
    (someContainer: C1, anotherContainer: C2) -> Bool {

        // 检查两个Container的元素个数是否相同
        if someContainer.count != anotherContainer.count {
            return false
        }

        // 检查两个Container相应位置的元素彼此是否相等
        for i in 0..someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }

        // 如果所有元素检查都相同则返回true
        return true

}

通过 Where 语句来对关联类型定义约束。


END