Swift泛型(Generics)

// 泛型，交换两个数的值，Int， String等。inout关键字表示引用参数。
func swapTwoValues<T>(inout a: T, inout b: T) {
let temp = a
a = b
b = temp
}

var someInt = 10
var anotherInt = 20

swapTwoValues(&someInt, &anotherInt)

// "someInt = 20, anotherInt = 10"
println("someInt = \(someInt), anotherInt = \(anotherInt)")

// 泛型Stack
struct Stack<T> {
var items = [T]()

// mutating关键字表示该方法可以改变struct的成员，这里的items数组需要改变
mutating func push(item: T) {
items.append(item)
}

mutating func pop() -> T {
return items.removeLast()
}
}

// 指定泛型参数为String
var stackOfStrings = Stack<String>()

stackOfStrings.push("apple")

stackOfStrings.push("orange")

stackOfStrings // ["apple", "orange"]

stackOfStrings.pop() // ["orange"]

/**
类型约束语法

:param: someT 该类型要继承SomeClass类
:param: someU 该类型要遵守SomeProtocol协议
*/

/*
func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {

}
*/

// 找一个相等数值的泛型函数, 下面的写法会报错，因为泛型T可能是结构体和类等，它们不一定支持==，!=操作符。
/*
func findIndex<T>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if (value == valueToFind) {
return index
}
}
return nil;
}
*/

// 正确写法,Swift中有一个Equatable协议,遵循该协议的类实现 ==， !=操作符，所有Swift标准类型都支持Equatable协议。
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}

if let index = findIndex([0, 1, 2, 3, 4, 5], 3) {
println("index = \(index)")
index
} else {
println("index = nil")
}

// 关联类型行为
protocol Container {
typealias ItemType
mutating func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}

struct IntStack: Container {
var items = [Int]()
mutating func push(item: Int) {
items.append(item)
}

mutating func pop() -> Int{
return items.removeLast()
}

// 这句写不写都可以，Swift可以自动判别该类型
typealias ItemType = Int

mutating func append(item: Int) {
self.push(item)
}

var count: Int {
return items.count
}

subscript(i: Int) -> Int {
return items[i]
}
}
// 泛型版本
struct StackG<T>: Container {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}

mutating func pop() -> T {
return items.removeLast()
}

// typealias ItemType = T

mutating func append(item: T) {
self.push(item)
}

var count: Int {
return items.count
}

subscript(i: Int) -> T {
return items[i]
}
}

// where语句
/**
1.C1 C2要遵循Container协议
2.C1.ItemType == C2.ItemType，它们要相同
3.C1要遵循Equatable协议
*/
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

}