这周有点空 就把学习内容分开写好了.
之前那周事情比较多文章就快餐的写完就好了
泛型是一个神奇的语法,当然你学会不感受到他奇妙之处.不要好像我那样愚挫,成天捉狂.
泛型允许在函数,枚举,结构,类中,以及协议上自定义形参
泛型指定一个或多个类型占位符，类型暂时不确定，等具体调用的时候再确定
//标准类型
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
}