使用泛型的原因:

例如:

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 {}