使用泛型的原因:
例如:
class Object { }
class Stack1 {
var items = [Object]()
func push(item: Object) {
items.append(item)
}
func pop() -> Object {
return items.removeLast()
}
}
但是,如果传值的时候需要考虑的问题很多,也影响性能(例子存在问题)
var s = Stack1()
s.push("abc")
s.push(182)
s.push(MyClass())
因此需要这样设置泛型
//泛型类型
class Stack<T> {
var items = [T]()
func push(item: T) {
items.append(item)
}
func pop() -> T {
return items.removeLast()
}
}
//泛型函数
func swap<T>(inout first:T, inout second:T){
let temp=first
first=second
second=temp
}
var data1=100.87
var data2=200.22
swap(&data1, &data2)
关联类型
swift 不支持泛型的协议,但可以这样实现
1.通过 associatedtype 在 protocol 里定义关联类型
2.实现协议时,可以将关联类型设置为泛型类型参数
protocol Container {
associatedtype ItemType //关联类型
func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -> ItemType { get }
}
class Stack<T>: Container {
typealias ItemType=T
var items = [T]()
...
}
}
泛型约束
没有约束,泛型类型的功能就会很少
//泛型约束
func max<T:Comparable>(array: [T]) -> T {//Comparable是一个协议
var value=array[0]
for index in 1..<array.count
{
if array[index]>value {
value=array[index]
}
}
return value
}
多个约束
func max <T where T:Equatable ,T:Comparable>(array: [T]) -> T {}
