swift学习笔记->泛型

如果学过java就知道泛型是什么比如说定义一个数组 var a : [Int]

Int 就是该数组的泛型创建一个字典也是根据泛型储存内容的

var a : Dictionary <String,String>

而泛型能解决的问题就像字典一样他是个不确定的键值对你定义什么类型就能存什么类型

泛型函数

下面举个例子一个函数要将两个参数值互换

func  myswap(inout a: Int,inout b: Int) {
    let temp  = a
    a = b
    b = temp
　　
}

如上所写只能交换int类型数据如果要String类型呢是不是又要另外写一份？

这里用泛型就省力了把参数类型改成未知的一个泛型一般用 "T"

func  myswap<T>(inout a: T,inout b: T) {
    let temp  = a
    a = b
    b = temp
}

语法就不多解释了尖括号写的是泛型形参用就可以了

这样只要满足运算符"="操作的类型就能交换

泛型类型

在类或结构中定义一个泛型类型下面举个栗子

class Stack<Element> {
    var containers = [Element]()
     func push(e: Element) {
        containers.append(e)
    }
     func pop() -> Element {
        return containers.removeLast()
    }
}

var data: Stack<Int> = Stack<Int>()

这个类是模仿栈的结构有push入栈与pop出栈两个方法

类中的数组在类实例化时决定

泛型扩展

扩展时，不需要再指定泛型参数（尖括号里面的内容称之为泛型参数）

extension Stack {
    var count: Int {
        return containers.count
    }

　　func aa(e:Element){
　　　　print(e)
　　}

} 
var data2 = Stack<String>() 
data2.push("dasdf") 
data2.count

泛型约束

你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // function body goes here
}

上面这个假定函数有两个类型参数。第一个类型参数T，有一个需要T必须是SomeClass子类的类型约束；第二个类型参数U，有一个需要U必须遵循SomeProtocol协议的类型约束。

用处也跟泛型函数类似比如写一个查找数组中是否有该数有则返回下标没有则返回-1

func index<T:Equatable>(arr:[T],data: T) ->Int {
    for (m,n) in arr.enumerate() {
        if n == data  {
            return m
        }
    }
    return -1
}

这样写也就意味着“任何T类型都遵循Equatable协议” 如果有多个需要约束的协议则在Eqatableh

where T:类型，T:类型....

协议的关联类型修饰符 typealias

　　定义协议时我们无法声明泛型所以在协议中泛型写法变了一下

protocol Containter {
    typealias Element
    mutating func push(e: Element)
    mutating func pop()-> Element
}

实现该协议

struct MyStack: Containter{
    //   typealias Element = Int
    
    var containers = [Int]()
    mutating func push(e: Int) {
        containers.append(e)
    }
    mutating func pop() -> Int {
        return containers.removeLast()
    }
}

实现时经过swift类型推断实现为 Element = Int

实现后更改泛型名称也是可以的

struct Stack<Element,Com>: Containter {
    //按照当前的实现，下面的代码由于类型推断，可以省略
    //typealias Element = E
    var containers = [Element]()
    var com=[Com]()
    mutating func push(e: Element) {
        containers.append(e)
    }
    mutating func pop() -> Element {
        return containers.removeLast()
    }
    
}

扩展协议时的约束以及协议关联类型的使用

//定义两个协议MM,NN
protocol MM {
    
}
protocol NN : MM{
    
}
//分别实现协议MMClass，NNClass
class MMClass: MM {
    
}
class NNClass: NN {
    
}
//定义f泛型协议Container
protocol Container {
    typealias ItemType
}
//扩展泛型协议Container的泛型  使其受MM协议约束
extension Container where   ItemType: MM {
    var b: Int {return 5}
}
//扩展泛型协议Container的泛型  使其受NN协议约束
extension Container where   ItemType: NN {
    var b: Int {return 6}
}
//TestTest类实现Container协议
class TestTest: Container {
    typealias ItemType = MMClass //如果这里改为MMClass，那么aaaa.b输出结构是5
}
class TestTest2: Container {
    typealias ItemType = Int //若泛型类型的值不满足任何一个协议则无法访问b属性
}
let aaaa  = TestTest()
aaaa.b
let bbbb = TestTest2()
bbbb.b//报错