一、Swift泛型介绍

泛型是为Swift编程灵活性的一种语法,在函数、枚举、结构体、类中都得到充分的应用,它的引入可以起到占位符的作用,当类型暂时不确定的,只有等到调用函数时才能确定具体类型的时候可以引入泛型。
我们之前实际上已经使用过泛型,例如:SwiftArrayDictionary类型都是泛型集。

你可以创建一个Int数组,也可创建一个String数组,或者甚至于可以是任何其他Swift的类型数据数组。同样的,你也可以创建存储任何指定类型的字典(Dictionary),而且这些类型可以是没有限制的。

我们为什么要使用泛型呢?下面有个例子可以简单说明使用泛型的好处

//定义一个函数,要求追加数组数据到指定一个数组中
func appendIntToArray(src:[Int],inout dest:[Int])
{
// 遍历并加到数组后边
for element in src{
dest.append(element)
}
}
//使用copyIntArray添加整形数组数据
var arr = [2,5]
appendIntToArray([12,9], dest: &arr)
print(arr) // [2,5,12,9] //那么再要求让你实现添加字符串呢,好吧重写一个
func appendStringToArray(src:[String],inout dest:[String])
{
for element in src{
dest.append(element)
}
}
//使用copyStringArray添加字符串数组数据
var strArr = ["oc","swift"]
appendStringToArray(["php", "C#"], dest: &strArr)
print(strArr) // ["oc", "swift", "php", "C#"]
//如果有需要你实现添加其他类型呢?
//是不是每个类型都需要写一个对应的函数去实现,那这样就太复杂了!这时候我们就需要使用泛型
//定义泛型函数,在普通函数名后面加上<T>,T是个类型占用符,可以表示任何类型
func appendArray<T>(src:[T],inout dest:[T])
{
for element in src
{
dest.append(element)
}
}
//看到如此强大了吧?然后随意使用
var arr2 = [5,8]
appendArray([9,58], dest: &arr2) //appendArray自动识别要添加的数组数据类型
print(arr2) //[5, 8, 9, 58]
var strArr2 = ["renhairui","hello"]
appendArray(["nihao", "helloworld"], dest: &strArr2)
print(strArr2) //["renhairui", "hello", "nihao", "helloworld"]
var doubleArr = [1.2,3.4]
appendArray([6.5,1.0], dest: &doubleArr)
print(doubleArr) //[1.2, 3.4, 6.5, 1.0]

我的理解:泛型就是先占坑,具体占坑做什么,随你

二、Swift泛型使用

Swift泛型相关使用可分为以下几点:
  1. 泛型函数
  2. 泛型类型
  3. 泛型约束
  4. 泛型协议
1. 泛型函数,函数参数或返回值类型用泛型表示
//泛型函数定义式
func 函数名<泛型1,泛型2,…>(形参列表)->返回值类型
{
//函数体...
}
泛型函数使用实例
//定义一个泛型函数,把2个参数的值进行交换
func swapTwoValues<T>(inout valueOne: T, inout valueTwo: T) {
let temporaryA = valueOne
valueOne = valueTwo
valueTwo = temporaryA
}
//交换2个整形变量
var oneInt = 3
var twoInt = 107
swapTwoValues(&oneInt, valueTwo: &twoInt)
print("oneInt = \(oneInt), twoInt = \(twoInt)")
//打印:oneInt = 107, twoInt = 3
//交换2个字符串变量
var oneStr = "hello"
var twoStr = "world"
swapTwoValues(&oneStr, valueTwo: &twoStr)
print("oneStr = \(oneStr), twoStr = \(twoStr)")
//打印:oneStr = world, twoStr = hello
2. 泛型类型,在定义类型时使用泛型

使用也和泛型函数差不多,就是在类型名后面加上<泛型1,泛型2,…>,然后在类型里面直接使用泛型即可

//定义一个泛型结构体,用于压栈和出栈,泛型类型可以使用到类、结构体、枚举等各种类型
struct Stack<T> {
//栈在这里是个数组存储形式,数组中存储的数据类型是泛型类型
var items = [T]()
//因为压栈会修改实例值,需要加上mutationg关键字
mutating func push(item: T) {
items.append(item)
}
//因为出栈会修改实例值,需要加上mutationg关键字
mutating func pop() -> T {
return items.removeLast()
}
}
//创建一个字符串栈,栈里面存的是字符串
var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
print("出栈:\(stackOfStrings.pop()),栈中还剩:\(stackOfStrings.items)")
print("出栈:\(stackOfStrings.pop()),栈中还剩:\(stackOfStrings.items)")
print("出栈:\(stackOfStrings.pop()),栈中还剩:\(stackOfStrings.items)")
/* 打印:
出栈:cuatro,栈中还剩:["uno", "dos", "tres"]
出栈:tres,栈中还剩:["uno", "dos"]
出栈:dos,栈中还剩:["uno"]
*/
//创建一个整形栈,栈里面存的是整形
var stackOfInt = Stack<Int>()
stackOfInt.push(12)
stackOfInt.push(32)
stackOfInt.push(45)
stackOfInt.push(35)
print("出栈:\(stackOfInt.pop()),栈中还剩:\(stackOfInt.items)")
print("出栈:\(stackOfInt.pop()),栈中还剩:\(stackOfInt.items)")
print("出栈:\(stackOfInt.pop()),栈中还剩:\(stackOfInt.items)")
/* 打印:
出栈:35,栈中还剩:[12, 32, 45]
出栈:45,栈中还剩:[12, 32]
出栈:32,栈中还剩:[12]
*/
压栈:

出栈:

3. 泛型约束,为泛型类型添加约束
泛型约束大致分为以下几种:
  1. 继承约束,泛型类型必须是某个类的子类类型
  2. 协议约束,泛型类型必须遵循某些协议
  3. 条件约束,泛型类型必须满足某种条件
约束的大概使用格式
//继承约束使用格式
func 函数名<泛型: 继承父类>(参数列表) -> 返回值 {
//函数体,泛型类型是某个类的子类类型
}
//协议约束使用格式
func 函数名<泛型: 协议>(参数列表) -> 返回值 {
//函数体,泛型类型遵循某些协议
}
//条件约束使用格式
func 函数名<泛型1, 泛型2 where 条件>(参数列表) -> 返回值 {
//函数体,泛型类型满足某些条件
}
继承约束使用范例
//定义一个父类,动物类
class Animal{
//动物都会跑
func run(){
print("Animal run")
}
}
//定义狗类,继承动物类
class Dog: Animal {
override func run(){//重写父类方法
print("Dog run")
}
}
//定义猫类,继承动物类
class Cat: Animal {
override func run(){//重写父类方法
print("Cat run")
}
}
//定义泛型函数,接受一个泛型参数,要求该泛型类型必须继承Animal
func AnimalRunPint<T:Animal>(animal:T){
animal.run() //继承了Animal类的子类都有run方法可以调用
}
AnimalRunPint(Dog())
AnimalRunPint(Cat())
/* 打印:
Dog run
Cat run
*/
协议约束使用范例

Swift标准库中定义了一个Equatable协议,该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。

//定义泛型函数,为泛型添加协议约束,泛型类型必须遵循Equatable协议
func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
var index = 0
for value in array {
if value == valueToFind {//因为遵循了Equatable协议,所以可以进行相等比较
return index
} else {
index++
}
}
return nil
}
//在浮点型数组中进行查找,Double默认遵循了Equatable协议
let doubleIndex = findIndex([3.14159, 0.1, 0.25], valueToFind: 9.3)
if let index = doubleIndex {
print("在浮点型数组中寻找到9.3,寻找索引为\(index)")
} else {
print("在浮点型数组中寻找不到9.3")
}
//在字符串数组中进行查找,String默认遵循了Equatable协议
let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], valueToFind: "Andrea")
if let index = stringIndex {
print("在字符串数组中寻找到Andrea,寻找索引为\(index)")
} else {
print("在字符串数组中寻找不到Andrea")
}
/* 打印:
在浮点型数组中寻找不到9.3
在字符串数组中寻找到Andrea,寻找索引为2
*/
4. 泛型协议和条件约束

上面的Equatable协议实际上不是普通的协议,而是泛型协议,假设泛型类型必须遵循一个协议,此时就必须在协议中引入一个关联类型来解决。

//定义一个泛型协议,和其他泛型使用方式不同,这里泛型是以关联类型形式使用的
protocol Stackable{
//声明一个关联类型,使用typealias关键字
typealias ItemType
mutating func push(item:ItemType)
mutating func pop() -> ItemType
} struct Stack<T>:Stackable{
var store = [T]()
mutating func push(item:T){//实现协议的push方法要求
store.append(item)
}
mutating func pop() -> T {//实现协议的pop方法要求
return store.removeLast()
}
}
//创建Stack结构体,泛型类型为String
var stackOne = Stack<String>()
stackOne.push("hello")
stackOne.push("swift")
stackOne.push("world")
let t = stackOne.pop()
print("t = \(t)") //结果:t = world //添加泛型条件约束,C1和C2必须遵循Stackable协议,而且C1和C2包含的泛型类型要一致
func pushItemOneToTwo<C1: Stackable, C2: Stackable
where C1.ItemType == C2.ItemType>(inout stackOne: C1, inout stackTwo: C2)
{//因为C1和C2都遵循了Stackable协议,才有ItemType属性可以调用
let item = stackOne.pop()
stackTwo.push(item)
}
//定义另外一个结构体类型,同样实现Stackable协议,实际上里面的实现和Stack一样
struct StackOther<T>: Stackable{
var store = [T]()
mutating func push(item:T){//实现协议的push方法要求
store.append(item)
}
mutating func pop() -> T {//实现协议的pop方法要求
return store.removeLast()
}
}
//创建StackOther结构体,泛型类型为String
var stackTwo = StackOther<String>()
stackTwo.push("where")
//虽然stackOne和stackTwo类型不一样,但泛型类型一样,也同样遵循了Stackable协议
pushItemOneToTwo(&stackOne, stackTwo: &stackTwo )
print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)")
//打印:stackOne = ["hello"], stackTwo = ["where", "swift"]

iOS学习笔记47-Swift(七)泛型的更多相关文章

  1. [置顶] iOS学习笔记47——图片异步加载之EGOImageLoading

    上次在<iOS学习笔记46——图片异步加载之SDWebImage>中介绍过一个开源的图片异步加载库,今天来介绍另外一个功能类似的EGOImageLoading,看名字知道,之前的一篇学习笔 ...

  2. iOS 学习笔记七 【博爱手把手教你使用2016年gitHub Mac客户端】

    iOS 学习笔记七 [博爱手把手教你使用gitHub客户端] 第一步:首先下载git客户端 链接:https://desktop.github.com 第二步:fork 大神的代码[这里以我的代码为例 ...

  3. iOS学习笔记-精华整理

    iOS学习笔记总结整理 一.内存管理情况 1- autorelease,当用户的代码在持续运行时,自动释放池是不会被销毁的,这段时间内用户可以安全地使用自动释放的对象.当用户的代码运行告一段 落,开始 ...

  4. iOS学习笔记总结整理

    来源:http://mobile.51cto.com/iphone-386851_all.htm 学习IOS开发这对于一个初学者来说,是一件非常挠头的事情.其实学习IOS开发无外乎平时的积累与总结.下 ...

  5. iOS学习笔记-自定义过渡动画

    代码地址如下:http://www.demodashi.com/demo/11678.html 这篇笔记翻译自raywenderlick网站的过渡动画的一篇文章,原文用的swift,由于考虑到swif ...

  6. iOS学习笔记——AutoLayout的约束

    iOS学习笔记——AutoLayout约束 之前在开发iOS app时一直以为苹果的布局是绝对布局,在IB中拖拉控件运行或者直接使用代码去调整控件都会发上一些不尽人意的结果,后来发现iOS在引入了Au ...

  7. IOS学习笔记25—HTTP操作之ASIHTTPRequest

    IOS学习笔记25—HTTP操作之ASIHTTPRequest 分类: iOS2012-08-12 10:04 7734人阅读 评论(3) 收藏 举报 iosios5网络wrapper框架新浪微博 A ...

  8. IOS学习笔记之关键词@dynamic

    IOS学习笔记之关键词@dynamic @dynamic这个关键词,通常是用不到的. 它与@synthesize的区别在于: 使用@synthesize编译器会确实的产生getter和setter方法 ...

  9. iOS学习笔记10-UIView动画

    上次学习了iOS学习笔记09-核心动画CoreAnimation,这次继续学习动画,上次使用的CoreAnimation很多人感觉使用起来很繁琐,有没有更加方便的动画效果实现呢?答案是有的,那就是UI ...

  10. 【Unity Shaders】学习笔记——SurfaceShader(七)法线贴图

    [Unity Shaders]学习笔记——SurfaceShader(七)法线贴图 转载请注明出处:http://www.cnblogs.com/-867259206/p/5627565.html 写 ...

随机推荐

  1. BandwagonHost 5个数据中心/机房Ping速度测试亲自体验

    我们选择Bandwagonhost服务器的原因之一在于有5个数据中心,而且与众多其他VPS不同之处在于可以自己后台切换机房和IP,这样我们 在遇到不满意的速度时候,可以自己切换其他机房更换,而且对于有 ...

  2. HDU 3001 Travelling (状压DP,3进制)

    题意: 给出n<=10个点,有m条边的无向图.问:可以从任意点出发,至多经过同一个点2次,遍历所有点的最小费用? 思路: 本题就是要卡你的内存,由于至多可经过同一个点2次,所以只能用3进制来表示 ...

  3. Ubuntu下编译C++ OpenCV程序并运行

            因为想试跑yolov3的缘故,所以装了ubuntu系统,直接通过U盘装的,并不像他们说的“折腾”,反而一切非常顺利,比装软件还简单.然后就是要用C++跑opencv的程序用于比赛,出于 ...

  4. CPP-STL:vector中的size和capacity

    在vector中与size()和capacity() 相对应的有两个函数: resize(size_type)和reserve(size_type). Size指目前容器中实际有多少元素,对应的res ...

  5. CPP-基础:c++读取ini文件

    配置文件格式是[JP]K=2EC156673E 2F4240 5595F6 char str[50];GetPrivateProfileString("JP", "K&q ...

  6. ES6中const的用法

    const声明一个只读的常量.一旦声明,常量的值就不能改变.且const一旦声明变量,就必须立即初始化,不能留到以后赋值. const的作用域与let命令相同:只在声明所在的块级作用域内有效. con ...

  7. python之道13

    看代码分析结果 func_list = [] for i in range(10): func_list.append(lambda :i) v1 = func_list[0]() v2 = func ...

  8. Bootstrap滚动监听(Scrollspy)插件

    Bootstrap滚动监听(Scrollspy)插件,即自动更新导航插件,会根据滚动条的位置自动更新对应的导航目标

  9. CF-1093 (2019/02/10)

    CF-1093 1093A - Dice Rolling 输出x/2即可 #include<bits/stdc++.h> using namespace std; int main() { ...

  10. 【思维题 集合hash 树上差分】11.5撸树

    要注重问题的转化和一些结论的推断 题目描述 要致富,先撸树. 一棵树的形状可以简化为一张 $N$ 个点 $M$ 条边的图,由于装备条件限制,你只有撸两次,也就是删去两条边,当这张图不联通时,就意味着树 ...