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
        
}