Swift学习:泛型

本篇将详细总结介绍Swift泛型的用法; Swift泛型代码让你能够根据自定义的需求,编写出适用于任意类型、灵活可重用的函数及类型。它能让你避免代码的重复,用一种清晰和抽象的方式来表达代码的意图。

主要内容: 1.泛型解决的问题 2.泛型函数 3.泛型类型 4.扩展一个泛型类型 5.泛型的类型约束 6.关联类型

一、泛型解决的问题

Swift泛型代码让你能够根据自定义的需求,编写出适用于任意类型、灵活可重用的函数及类型。它能让你避免代码的重复,用一种清晰和抽象的方式来表达代码的意图。这种说法很模糊,下面我们结合一个示例来说明泛型的作用。 需求描述:使用函数来交换两个变量的值

//互换两个整型
func swapTwoInt(a:inout Int , b:inout Int){
    (a, b) = (b, a)
}

//互换两个Double
func swapTwoDouble(a:inout Double, b:inout Double){
    (a,b) = (b,a)
}

代码分析: swapTwoInt与swapTwoDouble两个函数功能相同,唯一的区别就是传入的变量类型不同。这样的代码看起来重复又累赘。在实际应用中,通常需要一个更实用更灵活的函数来交换两个任意类型的值,幸运的是,泛型代码帮你解决了这种问题。

二、泛型函数

泛型函数可以适用于任何类型,下面的swapTwoValues(::)函数是上面两个函数的泛型版本,可以交换任意类型的两个变量。 尖括号里声明一种通用类型T,参数列表里可以使用这种类型名表示通用类型

func SwapTwoThing<T>(a:inout T, b:inout T){
    (a, b) = (b, a)
}

var a = 100
var b = 200
swapTwoInt(a: &a , b: &b)
a  //200
b  //100

var string1 = "hello"
var string2 = "world"
SwapTwoThing(a: &string1, b: &string2)
string1  //world
string2  //hello

总结泛型函数的使用: 1.使用了占位类型名(T),来替换实际类型名(Int,Double); 2.占位类型符并不指定T必须是什么类型,但是却限制了参数a和b必须是同一种类型T; 3.只有SwapTwoValues<T>(:)函数在调用时,才能根据所传入的实际类型决定T所代表的类型; 4.T只是一个符号,可以使用大写字母开头的驼峰命名法(例如T和MyTypeParameter)来为类型参数命名,以表明它们是占位类型,而不是一个值。

三、泛型类型

3.1.系统类型使用到的泛型

事实上,泛型类型的使用贯穿了Swift语言。例如,Swift的Array和Dictionary都是泛型集合。你可以创建一个Int数组,也可创建一个String数组。

let arr = Array<Int>()
let dict = Dictionary<String,Int>()
let set  = Set<Float>()

3.2.自定义泛型类型:实现一个栈结构体

除了泛型函数,Swift还允许你定义泛型类型;这些自定义类、结构体和枚举可以适用于任何类型,类似于Array和 Dictionary。下面的示例就是创建一个具有栈功能的结构体,适用于各种类型。

struct Stack<Element>{
    //存放栈中变量的数组
    var items = Array<Element>()
    
    //入栈:向栈中添加一个新元素
    mutating func push(item:Element){
        items.append(item)
    }
    
    //出栈:删除栈顶元素,并返回此元素
    mutating func pop() ->Element?{
        return items.removeLast()
    }
}

var stack = Stack<Int>()
stack.push(item: 11)
stack.push(item: 22)
stack.pop()   //22

var stack1 = Stack<String>()
stack1.push(item:"aaa")
stack1.push(item:"bbb")
stack1.pop()  //“bbb"

3.3.自定义泛型类型:多个占位符

自定义泛型类型可以设置多个类型占位符,下面就是自定义了一个泛型类型Pair,它具有两个占位类型符。

struct Pair<T1, T2>{
    var t1:T1
    var t2:T2
}
var pair1 = Pair(t1: "hello", t2: "hi")
print(pair1)   //Pair<String, String>(t1: "hello", t2: "hi")
var pair2:Pair<String, Int> = Pair(t1:"hello",t2: 123)
print(pair2)   //Pair<String, Int>(t1: "hello", t2: 123)

四、扩展一个泛型类型

扩展一个泛型类型,可以直接使用原始类型定义中声明的类型参数列表,并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用。 比如,我们现在扩展泛型类型Stack,为其添加计算型属性topItem,用于获取栈顶元素,代码示例如下:

extension Stack {
    //返回当前栈顶元素而不会将其从栈中移除
    var topItem: Element? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}
var stack3 = Stack<Int>()
stack3.push(item:1)
stack3.push(item:2)
stack3.push(item: 3)
if let topItem = stack3.topItem{
    print("栈顶元素:\(topItem)")   //栈顶元素:3
}

注意:扩展中的占位类型符需要与原始类保持一致,所以这里用的还是Element。

五、泛型的类型约束

swapTwoValues(::)函数和Stack类型可以作用于任何类型。但如果可以为泛型函数和泛型类型的类型添加一个特定的类型约束,将会是非常有用的。 通常情况下,我们设置泛型类型约束的时候,会指定一个类型参数必须继承自指定类,或者符合一个特定的协议或协议组合。

5.1.类型约束语法

对泛型函数添加类型约束的基本语法如下所示(作用于泛型类型时的语法与之相同)。

//在一个类型参数名后面放置一个类名或者协议名,并用冒号进行分隔,来定义类型约束
func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 这里是泛型函数的函数体部分
}

5.2.泛型类型约束实践

下面的泛型函数用于查找数组中某个元素的索引位置;但由于for循环里用到了对象比较"==",要确保所有的类型都适用,所以在泛型函数的中添加了类型约束,使用此泛型函数的参数必须遵循Equatable协议。

func findIndex<T: Equatable>(of valueToFind: T, in array:[T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
let doubleIndex = findIndex(of: 9.3, in: [3.14159, 0.1, 0.25])  //nil
let stringIndex = findIndex(of: "Andrea", in: ["Mike", "Malcolm", "Andrea"]) //2

注意:Swift标准库定义了Equatable协议,该协议要求任何遵循该协议的类型必须实现等式符(==)及不等符(!=)。从而能对该类型的任意两个值进行比较。所有的Swift标准类型自动支持 Equatable 协议

六、关联类型

关联类型是在为协议中的某个类型提供一个占位名,其所代表的实际类型会在协议被采纳时才会被指定。这里涉及到两个关键字,其作用就是给一个类型起一个别名,首先来说明一下: associatedtype(协议声明中使用) typealias (协议实现中使用) 下面通过一个示例来理解关联类型的作用:定义一个可称重的协议,其中使用了泛型关联类型。这种方式可以更大程度的使用协议,具体实现协议的时候再决定类型。

protocol WeightCaclulable{
    //associatedtype设置别名,即关联类型
    associatedtype WeightType
    var weight:WeightType{get} //返回重量属性,其类型是WeightType
}

//iphone7:手机较轻,表示重量时会有小数点,所以使用Double描述
class Iphone7:WeightCaclulable{
    //实现的时候用的是typealias
    typealias WeightType  = Double
    
    var weight: Double {
        return 0.114
    }
}
//Ship:轮船较重,表示重量可以忽略小数,所以使用Int描述
class Ship:WeightCaclulable{
    typealias WeightType = Int
    var weight: WeightType
    
    init(weight:WeightType) {
        self.weight = weight
    }
}
let iphone7 = Iphone7()
print(iphone7.weight)  //0.114
let ship = Ship(weight: 100000)
print(ship.weight)     //100000

6.1.关联类型添加约束

协议中存在关联类型,我们也可以为其添加约束,下面是一个Container协议,我们设置其关联类型Item遵循了协议Equatable,具体代码如下:

protocol Container {
    associatedtype Item: Equatable
    
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Fundebug

JavaScript的值传递和引用传递

1063
来自专栏九彩拼盘的叨叨叨

JavaScript 数组练习题

** 题 1:查找数组对象中 age 大于 18 对象 ** 编写函数 filterAdult,满足

961
来自专栏desperate633

LintCode 合并排序数组 II题目代码

合并两个排序的整数数组A和B变成一个新的数组。 注意事项 你可以假设A具有足够的空间(A数组的大小大于或等于m+n)去添加B中的元素。

642
来自专栏数据结构与算法

1081 线段树练习 2 单点查询及区间修改

1081 线段树练习 2 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 大师 Master 题目描述 Description ...

3279
来自专栏文武兼修ing——机器学习与IC设计

调度队列的优先堆实现应用场景模拟应用分析代码实现

应用场景模拟 考虑优先堆的一种应用场景——按优先级的任务调度队列:每个任务有一个优先级和唯一标号,该调度队列需要具有以下功能: 添加任务:将任务添加进调度队列并...

36310
来自专栏鸿的学习笔记

一句话讲明白基本排序

422
来自专栏我是攻城师

Scala中的case match语法

3023
来自专栏SeanCheney的专栏

《利用Python进行数据分析·第2版》第3章 Python的数据结构、函数和文件3.1 数据结构和序列3.2 函数3.3 文件和操作系统3.4 结论

本章讨论Python的内置功能,这些功能本书会用到很多。虽然扩展库,比如pandas和Numpy,使处理大数据集很方便,但它们是和Python的内置数据处理工具...

4736
来自专栏章鱼的慢慢技术路

追踪状态——消息解码问题的思路剖析

1783
来自专栏数据结构与算法

1470 数列处理

个人博客:doubleq.win 1470 数列处理  时间限制: 1 s  空间限制: 1000 KB  题目等级 : 青铜 Bronze 题解 题目描述 D...

2715

扫码关注云+社区

领取腾讯云代金券