泛型（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>代表T是类型参数，就像数组里面的Array<Element>
func swapTwoValues<T>(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<Element> {//声明一个<Element>泛型
var items = Element
mutating func push(item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}
var stackOfStrings = Stack<String>()//在这里用<String>说明储存的是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<Key, Value> ）虽然都是泛型但是字典的键必须满足Hashable 协议。这时候就需要对泛型进行约束了。对泛型的约束有两种。如下面的语法结构：

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
// function body goes here
}```
约束1：<T: SomeClass>对T的约束是T必须是SomeClass的子类。
约束2：<U: SomeProtocol>对U的约束是U必须实现SomeProtocol这个协议。
类型约束举例：
如下定义一个findIndex函数参数是泛型T，并且通过<T: Equatable>约束T必须实现Equatable这个协议。

func findIndex<T: Equatable>(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<Element>: Container {
// original Stack<Element> 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<C1: Container, C2: Container where C1.ItemType == C2.ItemType, C1.ItemType: Equatable> (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..<someContainer.count {
if someContainer[i] != anotherContainer[i] {
return false
}
}
// all items match, so return true
return true
}```
即使stackOfStrings属于结构体Stack类型，arrayOfStrings属于数组类型，他们的类型不同，但是他们满足上面的条件即：stackOfStrings元素个数和arrayOfStrings元素个数相同并且对于每一个stackOfStrings[i]都等于arrayOfStrings[i]，所以判断结果是stackOfStrings和arrayOfStrings相同将打印All items match.

 var stackOfStrings = Stack<String>()
 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."```