泛型（Generics）

泛型的概念：

func swapTwoInts(inout a: Int, inout _ b: Int) {
     let temporaryA = a
     a = b
     b = temporaryA
}//只能交换int类型
 var someInt = 3
 var anotherInt = 107
 swapTwoInts(&someInt, &anotherInt)
 print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
 // Prints "someInt is now 107, and anotherInt is now 3"

这里有一个方法交换int 类型的两个变量，当我们想要交换两个double类型或者string类型的变量又要分别写别的两个函数。这时我们的泛型就展示出来它的优势了，泛型可以用一个方法，代表所有的类型的变量的值交换。但要求这两个变量是相同的类型。

泛型的写法如下：

//在方法名后面加上代表T是类型参数，就像数组里面的Array
 func swapTwoValues(inout a: T, inout _ b: T) {
      let temporaryA = a
      a = b
      b = temporaryA
 }//可以交换任意类型，但是这两个值的类型必须相同
 //交换int类型
 var someInt = 3
 var anotherInt = 107
 swapTwoValues(&someInt, &anotherInt)
 // someInt is now 107, and anotherInt is now 3
 //交换string类型
 var someString = "hello"
 var anotherString = "world"
 swapTwoValues(&someString, &anotherString)
 // someString is now "world", and anotherString is now "hello"

下面再举一个例子分别定义一个只能储存int类型的IntStack 结构体栈，和可以储存任意类型的Stack结构体栈：

//只能储存int类型
 struct IntStack {
     var items = [Int]()
     mutating func push(item: Int) {
          items.append(item)
     }
     mutating func pop() -> Int {
          return items.removeLast()
     }
 }
 //运用了泛型可以储存任意类型
 struct Stack {//声明一个泛型
     var items = [Element]()
     mutating func push(item: Element) {
            items.append(item)
     }
     mutating func pop() -> Element {
            return items.removeLast()
    }
 }
 var stackOfStrings = Stack()//在这里用说明储存的是string类型
 stackOfStrings.push("uno")
 stackOfStrings.push("dos")
 stackOfStrings.push("tres")
 stackOfStrings.push("cuatro")
 // the stack now contains 4 strings
 let fromTheTop = stackOfStrings.pop()
 // fromTheTop is equal to "cuatro", and the stack now contains 3 strings

泛型的扩展:

接着上边的代码可以对Stack 栈进行扩展如：给Stack 扩展一个类型为Element的topItem属性。

extension Stack {
     var topItem: Element? {
            return items.isEmpty ? nil : items[items.count - 1]
     }
 }
 if let topItem = stackOfStrings.topItem {
      print("The top item on the stack is \(topItem).")
 }
 // Prints "The top item on the stack is tres."

类型约束:

并不是所有的类型都能满足函数中的泛型参数，正如字典的键和值（Dictionary ）虽然都是泛型但是字典的键必须满足Hashable 协议。这时候就需要对泛型进行约束了。对泛型的约束有两种。如下面的语法结构：

func someFunction(someT: T, someU: U) {
     // function body goes here
 }

约束1：对T的约束是T必须是SomeClass的子类。
约束2：对U的约束是U必须实现SomeProtocol这个协议。
类型约束举例：
如下定义一个findIndex函数参数是泛型T，并且通过约束T必须实现Equatable这个协议。

func findIndex(array: [T], _ valueToFind: T) -> Int? {
     for (index, value) in array.enumerate() {
          if value == valueToFind {
              return index
          }
     }
     return nil
 }
 let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
 // doubleIndex is an optional Int with no value, because 9.3 is not in the array
 let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
 // stringIndex is an optional Int containing a value of 2

相关类型:

相关类型跟泛型一样，就是一个暂时不确定的，没有指定的类型，当声明一个协议的时候，有时候需要定义一个或者多个相关类型来帮助协议的声明。相关类型用associatedtype 关键字来标识。

相关类型应用举例：

定义一个Container 协议里面有一个用associatedtype 标识的ItemType，ItemType就是一个相关类型，只有在实现协议的时候才赋值确定ItemType是什么类型。但是能确定的是append方法必须有一个ItemType类型的item参数，subscript方法必须返回一个ItemType 类型的参数。

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

 //在这里IntStack结构体实现了Container 协议
 struct IntStack: Container {
      // original IntStack implementation
      var items = [Int]()
      mutating func push(item: Int) {
          items.append(item)
      }
      mutating func pop() -> Int {
          return items.removeLast()
      }
    // conformance to the Container protocol
    //将ItemType 赋值为具体的Int型，并实现协议的其他方法
     typealias ItemType = Int
     mutating func append(item: Int) {
         self.push(item)
     }
     var count: Int {
        return items.count
     }
     subscript(i: Int) -> Int {
         return items[i]
     }
 }

还可以通过泛型实现Container 协议

struct Stack: Container {
     // original Stack implementation
     var items = [Element]()
     mutating func push(item: Element) {
          items.append(item)
     }
     mutating func pop() -> Element {
          return items.removeLast()
    }
    // 这里实现Container 协议的方法
    mutating func append(item: Element) {
          self.push(item)
    }
    var count: Int {
          return items.count
    }
    subscript(i: Int) -> Element {
          return items[i]
    }
 }

扩展已经存在的类型指定一个相关类型:

Array已经存在了append(_:)函数，count属性，以及通过Int的参数元素返回一个subscript所有Array可以实现这个Container 协议并且，写一个空的表达式，写法如下：

extension Array: Container {}

这样你就可以用Container 一样用任何数组。

Where 语句:

接着上面的代码，声明一个allItemsMatch方法通过where语句约束C1要实现Equatable协议，通过自定义的Equatable协议判断实现了Container协议的任意两种类型C1和C2是否相等。判断依据是：
1.someContainer.count != anotherContainer.count返回false。如果someContainer和anotherContainer的元素个数不相等则someContainer和anotherContainer不相等。
2.someContainer[i] != anotherContainer[i]返回false。对任意i如果someContainer[i]和anotherContainer[i]不相等则omeContainer和anotherContainer不相等。
3.如果上面两个条件都满足相等那么返回true则omeContainer和anotherContainer相等。

func allItemsMatch (someContainer: C1, _ anotherContainer: C2) -> Bool {
      // check that both containers contain the same number of items
     if someContainer.count != anotherContainer.count {
            return false
     }
     // check each pair of items to see if they are equivalent
     for i in 0..

即使stackOfStrings属于结构体Stack类型，arrayOfStrings属于数组类型，他们的类型不同，但是他们满足上面的条件即：stackOfStrings元素个数和arrayOfStrings元素个数相同并且对于每一个stackOfStrings[i]都等于arrayOfStrings[i]，所以判断结果是stackOfStrings和arrayOfStrings相同将打印All items match.

 var stackOfStrings = Stack()
 stackOfStrings.push("uno")
 stackOfStrings.push("dos")
 stackOfStrings.push("tres")
 var arrayOfStrings = ["uno", "dos", "tres"]
 if allItemsMatch(stackOfStrings, arrayOfStrings) {
         print("All items match.")
 } else {
        print("Not all items match.")
 }
 // Prints "All items match."