Swift泛型编程 geekband

这周有点空 就把学习内容分开写好了.
之前那周事情比较多文章就快餐的写完就好了

泛型是一个神奇的语法,当然你学会不感受到他奇妙之处.不要好像我那样愚挫,成天捉狂.
泛型允许在函数,枚举,结构,类中,以及协议上自定义形参
泛型指定一个或多个类型占位符，类型暂时不确定，等具体调用的时候再确定

//标准类型
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
}

//其中T可以是Int和String 还有很多 这里不举栗子
var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
//这时候T的类型为 int

var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
  //这时候T的类型为 String

 ////设置U为不合法,应当基类类型或其他函数类型.
class swapOneValues <T> : swapTwoValues<U>{
//...
}

//参数实例化
var text1= swapTwoValues <String>()
var text2= swapTwoValues <Double>()
var text3= swapTwoValues <int>()

协议的关联类型<协议泛型>

protocol Container {
//关联类型 typealias可以为protocol定义一到多个管理类型
//关联类型也是占位符
//关联类型 可以看做为支持"泛型版的协议"
typealias ItemType

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

class Stack<T>: Container {
//T= Container.ItemType 可以这样理解吧
typealias ItemType=T

var items = [T]()

func push(item: T) {
    items.append(item)
}

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

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

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

//泛型使用
var stack1=Stack<String>()
stack1.append("Earth")
var stack2=Stack<Int>()
stack2.append(1)
stack2.append(2)
stack2.count

泛型约束

//协议约束 + where句子约束

//where约束,指定关联类型必须符合某种协议,或者其他关联类型等
func find<T:Container where T.ItemType: Equatable>(sequence :T, item:T.ItemType)->Bool{

for index in 0..<sequence.count{
    
    if(sequence[index]==item){
        return true
    }
}

return false
}

//T:支持约束类型 Comparable是基类约束,另一种是协议约束
func max<T:Comparable>(array: [T]) -> T {
var value=array[0]

for index in 1..<array.count
{
    if array[index]>value {
        value=array[index]
    }
}
return value
}