Swift泛型编程 geekband

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

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

//标准类型
func swapTwoInts(inout a: Int, inout b: Int){
let temporaryA = a
a = b
b = temporaryA
}
//泛型
func swapTwoValues(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  : swapTwoValues{
//...
}

//参数实例化
var text1= swapTwoValues ()
var text2= swapTwoValues ()
var text3= swapTwoValues ()

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

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

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

class Stack: 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()
stack1.append("Earth")
var stack2=Stack()
stack2.append(1)
stack2.append(2)
stack2.count

泛型约束

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

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

for index in 0..(array: [T]) -> T {
var value=array[0]

for index in 1..value {
        value=array[index]
    }
}
return value
}