swift 泛型

·  阅读 543

这是我参与更文挑战的第23天,活动详情查看: 更文挑战

泛型

  • 泛型是为Swift编程灵活性的一种语法,在函数、枚举、结构体、类中都得到充分的应用,它的引入可以起到占位符的作用,当类型暂时不确定的,只有等到调用函数时才能确定具体类型的时候可以引入泛型
  • 泛型可以理解为:泛型就是占位符

泛型函数

  • 函数的泛型使用了占位类型名(在这里用字母 T 来表示)来代替实际类型名(例如 IntString)。占位类型名没有指明 T 必须是什么类型,但是它指明了 a 和 b 必须是同一类型 T,无论 T 代表什么类型。只有 swapTwoValues(::) 函数在调用时,才会根据所传入的实际类型决定 T 所代表的类型。
  • 泛型函数和非泛型函数的另外一个不同之处,在于这个泛型函数名(swapTwoValues(::))后面跟着占位类型名(T),并用尖括号括起来(<T>)。这个尖括号告诉 Swift 那个 T 是 swapTwoValues(::) 函数定义内的一个占位类型名,因此 Swift 不会去查找名为 T 的实际类型
//非泛型函数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoStrings(_ a: inout String, _ b: inout String) {
    let temporaryA = a
    a = b
    b = temporaryA
}

//泛型函数
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}
复制代码

类型参数

  • 类型参数指定并命名一个占位类型,并且紧随在函数名后面,使用一对尖括号括起来(例如 <T>
  • 多个类型参数,将它们都写在尖括号中,用逗号分开
  • 命名类型参数:通常使用单个字母来命名
  • 始终使用大写字母开头的驼峰命名法(例如 T 和 MyTypeParameter)来为类型参数命名,以表明它们是占位类型,而不是一个值

类型约束

  • 类型约束可以指定一个类型参数必须继承自指定类,或者符合一个特定的协议或协议组合
  • 在一个类型参数名后面放置一个类名或者协议名,并用冒号进行分隔,来定义类型约束,它们将成为类型参数列表的一部分
第一个类型参数A,A必须是ClassA子类的类型约束
第二个类型参数B,B必须符合ClassB协议的类型约束
func doSomething<A:ClassA,B:ClassB>(someA:A someB:B){
    
}
复制代码

关联类型

  • 关联类型为协议中的某个类型提供了一个占位名,代表的实际类型在协议被采纳时才会被指定
  • 通过 associatedtype 关键字来指定关联类型
protocol Container {
    associatedtype ItemType
    mutating func append(_ item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}
复制代码

这个协议没有指定元素必须是何种类型,为了满足这三个条件,Container 协议需要在不知道容器中元素的具体类型的情况下引用这种类型。Container 协议需要指定任何通过 append(_:) 方法添加到容器中的元素和容器中的元素是相同类型,并且通过容器下标返回的元素的类型也是这种类型,为了达到这个目的,Container 协议声明了一个关联类型 ItemType,写作 associatedtype ItemType。这个协议无法定义 ItemType 是什么类型的别名,这个信息将留给遵从协议的类型来提供

struct Stack<Element>: Container {
    // Stack<Element> 的原始实现部分
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // Container 协议的实现部分
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
复制代码

泛型 where 语句

下面这个泛型函数在类型参数里面添加了where子句约束,C1,C2都必须是采纳Container协议的类型,并且C1、C2的泛型类型必须相同,而且C1的泛型类型必须是符合Equatable

protocol Container{
    typealias itemType 
    mutating func append(item:itemType)
    var count:Int{get}
    subscript(i:Int)->itemType {get}
}

func allItemsMatch<C1:Container,C2:Container where C1.itemType == C2.itemType,C1.itemType:Equatable>(someContainer:C1,_ anotherContainer:C2) -> Bool{
    if someContainer.count != anotherContainer.count{
        return false
    }
    
    for i in 0...someContainer.count-1{
        if someContainer[i] != anotherContainer[i]{
            return false
        }
    }
    return true
}
复制代码
分类:
iOS
标签:
收藏成功!
已添加到「」, 点击更改