下面定义了一个普通类和一个泛型类必威,在J

本篇文章主要介绍泛型的应用。

在.NET中泛型使用非常频繁,在控制台应用程序中,默认的引入了System.Collection.Generics名称空间,其中就提供了我们经常使用的泛型:List<T>和Dictionary<T>,相信用过它们的都知道它们的强大。还有一种我们经常使用的简单的泛型:System.Nullable<T>,即可空类型。我们可以:

泛型、函数类型、闭包

本篇中整理了学习泛型时的知识点, 如果有什么错误的地方, 请留言

八、泛型程序设计:

泛型是.NET Framework 2.0 版类库就已经提供的语法,主要用于提高代码的可重用性、类型安全性和效率。

System.Nullable<int> nullableInt;

泛型

泛型是什么?简单说来泛型就是泛指的类型,里面可以实例化任何你想要的类型。
比如我想写个函数交换两个数大小:

泛型的概念

泛型代码可根据自定义需求,写出适用于任何类型、灵活且可重用的函数和类型,避免重复的代码,用一种清晰和抽象的思维表达代码的意思

    1.    泛型类的定义,见如下代码:

泛型的定义

声明一个可空的int类型,由于C#语法对这个做了简化通常我们都不这样写,而是这样写:

泛型函数

func exchange (x: inout Int, y: inout Int)
{
    let a = x
    x = y
    y = a 
}
var a = 55
var b = 22
print("a is (a), b is (b).")
//输出结果:a is 55, b is 22.
exchange(x: &a, y: &b)
print("After exchange: a is (a), b is (b).")
//输出结果:After exchange: a is 22, b is 55. 

好,看起来很完美,可是你有没有发现这个函数只能交换两个整数,如果要交换小数呢?也许你会说,这不简单,把参数类型换成 Double 就好了嘛。可是如果你又想交换两个字符串呢?这样换来换去不是个办法,所以泛型自然应运而生。

func exchange<T>(x: inout T, y: inout T)
{
    let a = x
    x = y
    y = a
}
var a = "xiaoMing"
var b = "xiaoHong"
print("a is (a), b is (b).")
//输出结果:a is xiaoMing, b is xiaoHong.
exchange(x: &a, y: &b)
print("After exchange: a is (a), b is (b).")
//输出结果:After exchange: a is xiaoHong, b is xiaoMing.

我们把参数类型换成 T ,然后在函数名后面加一个尖括号,也写上T ,实际上你可以写上任何你想写的字符,只要后面参数类型与它保持一致就行了。
一点点小改动,现在我们即可用来交换整数,又可以交换字符串啦。
现在看起来貌似很不错了,可是如果你想比较 a 和 b 大小可能会碰到一点小问题。你如何能保证传进去的参数支持 “<”、“>” 呢?幸好 Swift 早就想好这个问题了,所以引入了泛型约束。

泛型函数

示例:

/// 交换变量的值
func exchange<T>(_ one: inout T, _ two: inout T) {
    (one, two) = (two, one)
}

var a = 10.0
var b = 20.0

print("a = (a), b = (b)")     // a = 10.0, b = 20.0
exchange(&a, &b)               // 交换a和b的值
print("a = (a), b = (b)")     // a = 20.0, b = 10.0

var c = "hellow"
var d = "world"

print("a = (c), b = (d)")     // a = hellow, b = world
exchange(&c, &d)               // 交换c和d的值
print("a = (c), b = (d)")     // a = world, b = hellow
  • 上述代码中, exchange(_:_:)函数就是一个泛型函数

  • <T>中的<T>是一个占位类型, 在定义过程中不确定具体的类型, 只有在函数调用时, 根据传入的值的类型, 来推断出T的具体类型

    • exchange(&a, &b)TDouble类型
    • exchange(&c, &d)TString类型

注意: 泛型函数在调用的时候, 会根据传入的值推断出对应的类型

  • 泛型函数格式:
func 函数名<占位类型列表>(参数列表) {
    // 函数体
}
  • 注意:
    • 参数列表中, 占位类型列表中的占位类型必须在参数列表中使用
    • 如果参数列表中, 多个参数都属于相同的占位类型, 那么这些参数必需传入一致的类型数据, 例如: 全部传入Int, String, 或Double
    • 占位类型列表可以有多个占位类型, 使用逗号分开
 1     public class Pair<T,U> {
 2         public Pair() { first = null; second = null; }
 3         public Pair(T first,U second) { this.first = first; this.second = second; }
 4         
 5         public T getFirst() { return first; }
 6         public U getSecond() { return second; }
 7         public void setFirst(T first) { this.first = first; }
 8         public void setSecond(U second) { this.second = second; }
 9         
10         private T first;
11         private U second;
12     }

下面定义了一个普通类和一个泛型类,我们可以明确看到泛型类和普通类最大的区别就是多了一个<T>。

int? nullableInt

泛型约束

这个怎么用,看代码:

func max<T:Comparable>(array: [T]) -> T {
    var value=array[0]
    for index in 1..<array.count
    {
        if array[index]>value {
            value=array[index]
        }
    }
    return value
}
var data1=[1,6,3,8,5,2]
var data2=[12.3, 87.6, 77.8, 20.1, 50.2]
let m1=max(array: data1) // m1 = 8
let m2=max(array: data2) // m2 = 87.6

和泛型函数非常类似,我们只是添加了一个泛型的返回值,再让函数名背后的泛型 T 遵循 Comparable 协议,就这么简单?就这么简单。
只要你传进去的类型遵循 Comparable 协议,那你就可以随意调用这个函数,大家可以点进去看看 Comparable 协议都实现了定义了哪些东西。这样,只要我们想拿该类型做什么事,我们就让他遵循什么协议就好了,如果你随意传个自己写的类,那编译器就会提示你错了,非常方便。

  • 除了协议约束,还有基类约束,二者语法一样,不再赘述。
  • Where 字句约束
func find<T:Container>(sequence :T, item:T.ItemType)->Bool where T.ItemType: Equatable{
 for index in 0..<sequence.count{
 if(sequence[index]==item){
            return true
        }
    }
    return false
} ```
这个奇奇怪怪的东西是什么?在了解它之前,我们得先知道协议的关联类型。
#### 关联类型

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 push(item: T) {
    items.append(item)
}

func pop() -> T {
    return items.removeLast()
}

func append(item: T) {
    self.push(item: item)
}

var count: Int {
    return items.count
}
subscript(i: Int) -> T {
    return items[i]
}

} ```
哇,不要说你看不懂,我也看晕了,怎么又是 T 又是 ItemType ,这都是些什么啊?
不要慌,先看第一个 Container,它是一个协议。其实它的意思如下伪码:

protocol Container<ItemType> {
 func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

是不是有点儿眉目了,这不就是泛型协议吗,Swift 为啥还要画蛇添足搞出一个关联类型出来?稍安勿躁,苹果这么做自然有他的好处了。
参考链接
我简单总结下好处:

  • 让代码更简洁清晰,特别是当你的协议需要定义多个泛型类型时
  • 可以使用“.”表达式,方便 where 约束
    好了,有了关联类型,我们就可以像上方那样使用 T.ItemType 的语法来用 where 约束了,是不是非常清晰明了,当你定义的 associatedtype 多了之后,好处就更加明显了。

类型参数

  • exchange(_:_:)函数中, 占位类型T就是一个类型参数的例子, 即: T是一个类型参数
  • 类型参数指定并命名一个占位类型, 并且紧随在函数名后面, 使用一对尖括号括起来(例如: <T>)
  • 一旦一个类型参数被指定, 就可以如下使用:
    • 用来定义一个函数的参数类型(例如: exchange(_:_:)中的one和two的类型)
    • 做为函数的返回值
    • 函数主体中的注释类型
  • 类型参数的定义过程中不会代表任何具体的类型, 只是一个占位, 当函数被调用时, 会根据传入的值的类型, 推断出具体类型, 例如上面的DoubleStirng替换掉T
  • 参数类型可以同时存在多个, 并用逗号分开, 例如: <T, U, S>为三个类型参数(占位类型), 名称分别为参数类型T, 参数类型U, 参数类型S
综上有泛型函数格式如下:
func 函数名<类型参数列表>(参数列表) {
   // 函数体
}

    以上代码中的T,U都是泛型类Pair的类型参数。以下为C++中模板类的定义方式:

所以,这个<T>就标记了,这个类是泛型类。其中这个T,也可以写成A,B,C,D或其他字符。

下面重点介绍一下如何自定义泛型。

函数类型与闭包

泛型类型

  • 泛型函数是在函数名的后面紧跟着类型参数列表, 而泛型类型就是在定义的类型的时候, 在类型名后面紧跟类型参数列表
 1     template<typename T,typename U>
 2     class Pair {
 3     public:
 4         Pair(T first,U second): _first(first),_second(second) {}
 5         ~Pair() {}
 6     public:
 7         T getFirst() { return _first; }
 8         U getSecond() { return _second; }
 9         void setFirst(T frist) { _first = first; }
10         void setSecond(U second) { _second = second; }
11     private:
12         T _first;
13         U _second;
14     }
public class Generic
{
    public String Name;
}

public class Generic<T>
{
    public T Name;
}

 

基本概念

闭包是函数类型的实例,而函数类型就是一个指针,类似于类,栈上储存指针,指向堆上的对象。

必威 1

函数类型内存模型.png

乍一看有点儿犯迷糊?不要紧,一个个来分析。
函数类型是一个指针,它在堆上有两个对象,这两个对象也是指针。一个叫对象指针,一个叫函数指针。

  • 对象指针:这个指针并不是每个函数类型的实例都会有,对象指针,看名字就知道它指向的是一个对象,至于什么样的函数类型拥有对象指针,咱们放到变量捕获那儿讲。
  • 函数指针:这个指向的就是这个函数类型里面的函数真正内存所在地
    函数类型怎么用呢?你可以将它用在任何使用类型的地方。例如:
  • 声明一个变量 var addInt : (Int, Int) -> Int 现在你可以将任何参数是两个 Int 返回值是一个 Int 的函数赋值给 addInt,就像使用一个变量去使用它,只不过现在该变量是一个函数。
  • 传递给某个函数作为一个参数
  • 将它作为某个函数的返回值
    这两种不具体写出来了,总之当做它是一个类型就可以了。
示例
  • 泛型类:
泛型类: 
class GenericClass<Element> {
    // 集合
    var items = [Element]()
    // 压栈
    func push(_ item: Element) {
        items.append(item)
    }
    // 出栈
    func pop() -> Element? {
        return items.isEmpty ? nil : items.removeLast()
    }
}
  • 泛型结构体
泛型结构体:
struct GenericStruct<Element> {
    // 集合
    var items = [Element]()
    // 压栈
    mutating func push(_ item: Element) {
        items.append(item)
    }
    // 出栈
    mutating func pop() -> Element? {
        return items.isEmpty ? nil : items.removeLast()
    }
}
  • 泛型枚举:
泛型枚举:
enum GenericEnum<Element> {
    case none
    case some(Element)
}
  • 上面的 GenericClass(类), GenericStruct(结构体), GenericEnum(枚举)都是泛型类型, 在类型名后紧跟着泛型的类型参数 <Element>
  • 泛型类型使用的时候, 需要指定类型参数的具体类型, 下面以结构体GenericStruct为例:
// 创建GenericStruct类型的机构体变量struct
// 指定类型参数为 Int
var struct = GenericStruct<Int>()
// 使用struct时, push(_:), pop()方法使用 类型参数的地方 都会替换为Int类型
struct.push(1)
struct.push(2)
struct.push(3)
struct.push("4")   // 报错: 因为push(_:)接收的参数类型已经被替换成Int

let result = struct.pop()   // result = 3

    2.    泛型方法的定义,在Java中泛型方法不一定声明在泛型类中,可以声明在普通类中,见如下代码:

泛型,顾名思义,就是泛指的类型。好比男人,女人,白人,黑人,可以泛称为【人】。

定义泛型类

函数类型实例化

那既然是一个类型,可以被赋值,那它支持哪些函数给它赋值呢?

  • 全局函数
  • 嵌套函数
//嵌套函数
func algorithmFunction(symbol:String)-> (Double, Double)->Double{

    func add(x:Double, y:Double)->Double{
        return x+y
    }

    func minus(x:Double, y:Double)->Double{
        return x-y
    }

    func multiply(x:Double, y:Double)->Double{
        return x*y
    }

    func divide(x:Double, y:Double)->Double{
        return x/y
    }

    switch(symbol){
    case "+":
        return add
    case "-":
        return minus
    case "*":
        return multiply
    case "/":
        return divide
    default:
        return add
    }
}
var algorithm=algorithmFunction(symbol: "/")
let result4 = algorithm(600,80)   // result4 = 7.5
  • 成员函数(实例方法与静态方法)
给泛型类型添加分类(extension)
  • 泛型类型添加分类时, 定义中不可以增加新的类型参数, 也不需要写已有类型参数(编译器也不允许写)
  • 错误写法:
错误一: 分类的定义中不可以增加新的类型参数
extension GenericClass<T> { }
错误二: 分类的定义中不需要写已经有的类型参数
extension GenericClass<Element> { }
  • 下面的代码是正确写法, 在分类中可以使用类型定义时有的类型参数:
extension GenericClass {
    // 使用已有的 类型参数: Element 做为返回值
    func element(at index: Int) -> Element? {
        if index < items.count {
            return items[index]
        }else {
            return nil
        }
    }
}

虽然在分类中无法定义新的类型参数, 但是可以在分类新定义的方法中引入其他的类型参数

extension GenericClass {
   func exchange<T>(one: inout T, two: inout T) {
       (one, two) = (two, one)
   }
}
 1     public class MyFirst {
 2         public static void main(String[] args) throws Exception {  
 3             String[] names = {"john","Q.","Public"};
 4             String middle = ArrayAlgo.<String>getMiddle(names);
 5             System.out.println(middle);
 6         }  
 7     }
 8     
 9     class ArrayAlgo {
10         public static <T> T getMiddle(T[] a) {
11             return a[a.length/2];
12         }
13     }

但类型只能是一个类型。 那么泛型和类型之间是什么关系呢?

创建泛型类是需要在类定义中用尖括号语法:

闭包

闭包就是函数类型实例,一样可用于变量、参数、返回值,他俩内存模型一致,那为啥要叫这个为闭包呢?说到这里不得不谈谈捕获了,在谈捕获前,想先介绍下内存泄漏。
内存在结构上可以分为堆和栈,栈上的内存由系统分配系统回收又迅捷又方便,不用我们操心。但栈的空间是极其有限的,所以必须要有堆来存放比较庞大的数据,在 Swift 中类和闭包的实例就存放在堆上并且受到 ARC 管理。
基础数值类型、结构、枚举、元组等不受 ARC 管理。
ARC 又叫自动引用计数管理机制,在堆上的对象只要有一个指针指向它,它的引用计数就加一,如图:

必威 2

引用计数示意.png

FileStream 此时的引用计数就为三,因为有三个指针指向它。当某个对象没有指针引用的时候,表明此对象没有任何利用价值了,ARC 会将引用计数降为零,并且销毁这个对象,释放所占内存。
好,目前看起来非常完美,perfect!可是,大家应该很快就会发现有个小问题:

必威 3

循环引用.png

这是两个类,每个类都有一个属性,而这个属性刚好又指向这两个类。真是你中有我我中有你不可分离啊,代码大概会是这样:

import Foundation
class Computer{
    var name: String
    var display: Monitor?
    init(name:String){
        self.name=name
        print("Computer init")
    }
    deinit{
        print("Computer deinit")
    }
}
class Monitor{
    var no: Int
    var device: Computer?
    init(no:Int){
        self.no=no
        print("Monitor init")
    }
    deinit{
        print("Monitor deinit")
    }
}
var imac:Computer?
var screen:Monitor?
imac=Computer(name: "Jason's iMac")
screen=Monitor(no: 29)
imac!.display=screen
screen!.device=imac
//imac!.display=nil
imac=nil
screen=nil
/* print : 
Computer init
Monitor init */

!!是不是少了点什么,析构器怎么没被调用?这就是经典的内存泄漏了。看了上面的内存模型,相信大家对这段代码为何会输出如此结构就了解了,这两个类对象还互相指着呢,引用计数都为一,怎么可能会被释放呢?
还好,世界上的聪明人早就猜到会发生这种事所以,我们有了处理这种办法的措施,那就是。。。手工赋值其中一个堆对象指针为 nil !哈,开个玩笑,其实这也是一种非常好的处理办法,非常灵活,下面我们来看看更普适的方法。

必威 4

内存泄漏处理办法.png

解决办法也着实简单,只要我们将其中一个强引用指针换成弱引用就 OK 了,也就是说这个弱引用指针将不被算进 ARC 引用计数里去,这样当栈上的两个指针断掉后,两个对象循环引用自然被打破,如图:

必威 5

弱引用.png

有时人们并不想该对象可被赋值为 nil,所以我们又创造了一个无主引用,和弱引用一样,只是无主引用声明的对象不许为 nil:

必威 6

无主引用.png

好了下面再来讲捕获。

泛型约束

  • 上述所有代码中, 不论是泛型函数中的 类型参数T , 还是泛型类型中的 类型参数Element , 都可以在调用时指定任意一个具体的类型做为替换, 这是因为我并没有给这些参数类型添加任何的约束
那么什么是 参数类型添加约束呢?

就拿我们经常使用的Dictionary为例, 我们知道Dictionary的定义中有两个参数类型, 分别为 KeyValue , 而且在给Dictionary添加元素的时候, key的值都是唯一的,即Dictionary根据Key的值来判断是修改还是增加元素, 而Swift中的Dictionary是根据Key的哈希值来判断唯一性的, 也就是说DictionaryKey值必须是可哈希的, 所以Dictionary的类型参数Key有一个约束, 那就是 可哈希的值

  • 下面是Dictionary定义的代码部分, 这里过滤里面的实现部分, 其中的where会在后面讲解
public struct Dictionary<Key, Value> : Collection, ExpressibleByDictionaryLiteral where Key : Hashable{}

    在以上代码中可以看出getMiddle方法为静态泛型方法,类型变量位于修饰符"public static" 的后面,返回值的前面。调用的时候在方法名的前面给出了参数类型。由于Java的编译器提供类型推演的功能,既类型参数可以通过函数参数的类型进行推演,因此也可以直接调用泛型函数,如String middle = ArrayAlgo.getMiddle(names)。如果编译器无法通过函数参数的类型推演出类型参数的实际类型,这样将会导致编译错误。在C++中同样存在模板函数,也同样存在模板函数的类型推演,在这一点上主要的差异来自于函数声明的语法,见如下C++代码:

其实很简单,泛型在定义的时候,是泛指类型;在使用的时候,就需要被指定,到底使用哪个类型。

class MyGenericClass<T>
{
    ...
}

捕获

必威 7

捕获.png

这里重点要讲的是捕获生存周期小于闭包对象的参数和局部变量,因为其他的值谈不上捕获,顶多算使用而已,但是这二者却截然不同,我们是真真正正的复制了他们封装在临时对象上,并且闭包的对象指针指向该临时对象。还记得前面讲函数类型时我说过不是所有函数类型的实例都会有这个对象指针吗?
有对象指针有两种情况,一是捕获了类的实例成员,包括实例方法和实例属性;二就是捕获了参数或局部变量。第一种就是将该闭包的对象指针指向该类的实例对象,第二种则是将对象指针指向闭包自己创建的临时对象。
并且,很重要一点,这个对象指针是强引用该对象,这样,大家可能明白又要出事情了。还是先看内存模型吧:

必威 8

捕获内存模型.png

似乎并没有什么不对,那我们现在思考一种情形。我是一个闭包,我捕获了类的实例成员,这样我的对象指针就将指向该实例对象;我是这个类,我定义了一个属性,该属性是这个闭包,这样我的实例对象就将有一个属性指针指向该闭包。看代码:

class Employee{
    var name: String
    var printer:(()->())?  
 /*   lazy var printer: (()->())? = {
        print("name: (self.name)")
    } */
   init(name:String){
        self.name=name
        self.printer = {
            print("name: (self.name)")
        }
        print("Employee init")
    }
     deinit {
     print("Employee deinit")
    }
}
var employee:Employee?
employee=Employee(name: "Jason")
employee?.printer?()
//employee?.printer=nil
employee = nil
/* print : 
Employee init
name: Jason */

同样析构器不会被调用,因为闭包和这个对象还两两相指呢,只有当我手动赋值该对象的闭包属性为 nil 时,析构器才会调用。看图:

必威 9

闭包循环引用.png

那解决办法大家应该也猜到了,同样是声明弱引用。

必威 10

弱引用.png

只放出不同部分: self.printer = { [weak self] in print("name: (self!.name)") }

必威 11

弱引用内存图.png

类型约束语法
  • 在定义一个类型参数时, 在类型参数后面放置一个类名或者协议名, 并用冒号分开, 来定义类型参数类型约束, 他们将成为类型参数列表的一部分
  • 示例:
泛型函数添加类型约束
func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // 这里是反省函数的函数体部分
}

泛型类型添加类型约束
class GenericClass<T: SomeClass, U: SomeProtocol> {
    // 类的实现部分
}
  • 上面的 泛型函数泛型类型 都分别有两个类型参数 TU, T有一个类型约束: 必须是SomeClass类的子类; U有一个类型约束: 必须遵守SomeProtocol协议的类型
 1     class ArrayAlgo {
 2     public:
 3         template<typename T>
 4         static T getMiddle(T* a,size_t len) {
 5             return a[len/2];
 6         }
 7     };
 8     
 9     int main()
10     {
11         int v[] = {1,2,3};
12         int ret = ArrayAlgo::getMiddle(v,3);
13         printf("This value is %d.n",ret);
14         return 0;
15     }

即,使用时,就不在是泛指类型,而是特定类型。

T可以是任意的标示符,只要遵守命名规则即可。

Weak-Strong Dance

这个有点儿诗意的名字是用来延长弱引用对象的生存周期的,别还没等到你要用,对象就被系统给咔嚓了。

必威 12

Weak-Strong Dance.png

下面运用了一点多线程知识,不详讲了,总之你要明白在代码中弱引用是非常不安全的。在进行一系列操作时,可能等不到你要使用它,就被系统回收了它的内存。在本例中,注释部分就是临时转换成一个强引用局部变量,没有被注释的代码就是 withExtendedLifetime 函数了。

import UIKit
class Employee {
 var name: String
 init(name:String){
        self.name=name
        print("Employee init")
    }
func doClosure() {
        DispatchQueue.global().async { [weak self] in
        /*
            self?.process("first process")
            usleep(500)
            self?.process("second process")
            */
       /*
            if let strongRef=self {
                strongRef.process("first process")
                usleep(500)
                strongRef.process("second process")
            }*/
          withExtendedLifetime(self){
                self?.process(message: "first process")
                usleep(500)
                self?.process(message: "second process")
            }   
        }
    }
 deinit {
        print("Employee deinit")
    }
    func process(message: String) {
        print(message)
    }
}
var employee: Employee? = Employee(name:"Jason")
employee?.doClosure()
DispatchQueue.global().async {
    usleep(100)
    employee = nil
}
dispatchMain()
/* print :
Employee init
first process
second process
Employee deinit
*/
类型约束实践
  • 现在有一个非泛型函数findIndex(ofString:in:), 该函数的功能是在一个String数组中查找给定的String值的索引, 若找到匹配的String值, 会返回该String值在String数组中的索引, 否则返回nil
func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {

    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
  • findIndex(ofString:in:)函数可以用于查找字符串数组中某个字符串的索引值
let strings = ["a", "b", "c", "d", "e"]
if let foundIndex = findIndex(of: "c", in: strings) {
    print("c 的索引值是 (foundIndex)")
}
// 打印: c 的索引值是 2
  • 我们知道, findIndex(ofString:in:)函数目前只能查找字符串在数组中的索引值, 用处不是很大。不过, 我们可以用占位类型T替换掉String类型来写出具有相同功能的泛型函数findIndex(of:in:)
  • 下面就是使用占位类型T替换掉String类型的代码:
func findIndex<T>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
  • 这段代码看上去可以查找任意的具体类型在该类型数组中的索引值, 但是在Xcode中并不能正常运行

  • 这是因为在Swift中, 想要比较两个值是否相等, 那么这两个值的类型必须实现了Equatable协议才可以

  • 对于未实现Equatable协议的类型, 比如我们自定义的类和结构体的实例, 是不能直接使用 == 来比较的, 因为这些实例并不知道"相等"意味着什么, 是部分内容相等才相等, 还是完全相等才算相等, 而Equatable就是用来说明"相等"意味着什么的

  • 因为只有遵守Equatable协议的类型才能进行相等判断, 所以上述可以被替换成为任意类型的T就不能符合要求, 所以我们需要给T加上一个类型约束: 想要替换占位类型T的具体类型, 必须遵守Equatable协议

  • 任何遵守Equatable协议的类型都可以在findIndex(of:in:)中正常运行, 代码如下:

func findIndex<T: Equatable>(of valueToFind: T, in array: [T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
  • findIndex(of:in:)唯一的类型参数叫做T: Equatable, 即: 任意符合Equatable协议的类型T

    3.    类型参数的限定:有些泛型函数在使用类型参数变量时,经常会用到该类型的特殊方法,如在进行数组元素比较时,要求数组中的元素必须是Comparable接口的实现类,见如下代码:

好比,定义时,定义了一个人。但在使用时,必须明确指定,到底是黑人还是白人。

 

第三周作业

关联类型(泛型协议)

  • 类、结构体和枚举的泛型类型中, 将类型参数列表放在了类型名的后面, 而在泛型协议中却不能这样写

  • 泛型协议的写法与泛型类型有所不同, 需要使用 associatedtype 关键字来指定类型参数

  • 泛型协议中的类型参数又被称为关联类型, 其代表的实际类型在协议被采纳时才会被指定

  • 下面一段代码就是有关联类型的协议:

protocol Container {
    associatedtype ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}
  • 协议Container定义了三个任何采纳该协议的类型必须提供的功能

    • 必须可以通过append(_:)方法添加一个类型为ItemType的新元素到容器里

    • 必须可以通过count属性获取容器中元素的数量, 并返回一个Int值

    • 必须可以通过索引值类型为Int的下标检索到容器中的每一个类型为ItemType的元素

  • 协议中无法定义ItemType的具体类型, 而任何遵从Container协议的类型都必须指定关联类型 ItemType 的具体类型

  • 下面的是一个非泛型的IntStack结构体, 采纳并符合了Container协议, 实现了Container协议的是三个要求:

struct IntStack: Container {
    // 集合数组, 用于存放元素
    var items = [Int]()

    // Container协议部分
    typealias ItemType = Int  // 通过关键字 typealias 指定ItemType的类型为Int
    mutating func append(item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}
  • IntStack在实现Container的要求时, 指定了ItemType的类型为Int, 即typealias ItemType = Int, 从而将Container协议中抽象的ItemType类型转换为具体的Int类型

  • 由于Swift的类型推断, 实际上不用再IntStack中特意的声明ItemType的类型为Int也可以, 这是因为IntStack符合Container协议的所有要求, 并且在方法中也将ItemType写成了Int类型, 这样Swift就可以推断出ItemType的类型为Int, 事实上, 在代码中删除typeealias IntType = Int这一行, 一切依旧可以正常工作

struct IntStack: Container {

    var items = [Int]()

    mutating func append(item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}
  • 上面的代码自动推断出 IntType 的类型是 Int

即: 对于泛型协议, 当有类型遵从该协议的时候, 只需要给未确定具体类型的关联类型所参与的所有方法中, 都给出唯一指定类型时, 并不需要特意声明该关联类型的声明也能正常运行, 原因就是Swift的自动推断

  • 也可以让泛型Stack结构体遵从Container协议
struct Stack<Element>: Container {
    var items = [Element]()
    // 由于所有需要关联类型的地方都指定了明确类型, 就不需要在特意的声明关联类型具体是什么类型了, 这里自动推断出 ItemType的类型是Stack对象创建时指定的泛型具体类型
    // typealias ItemType = Element
    mutating func append(item: Element) {
        self.items.append(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}
 1     public static <T> T min(T[] a) {
 2         if (a == null || a.length == 0)
 3             return null;
 4         T smallest = a[0];
 5         for (int i = 0; i < a.length; ++i) {
 6             if (smallest.compareTo(a[i]) > 0)
 7                 smallest = a[i];
 8         }
 9         return smallest;
10     }

泛型的使用

可以把类型用在类成员的返回类型,方法参数类型等,例如:

题目

请说出下面代码存在的问题,以及改进方式。
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("(name) is being deinitialized") }
}
class CreditCard {
    let number: UInt64
    let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #(number) is being deinitialized") }
}
通过扩展一个存在的类型来指定关联类型
  • 对于一个已经存在的类型, 并且在定义中没有遵守泛型协议, 我们可以在它的extension中遵守需要的泛型协议, 并且在该扩展中 也可以自动推导ItemType的类型, 并不需要写typealias ItemType = Element
struct Stack<Element> {
    var items = [Element]()
}
// 通过扩展遵从泛型协议 Container
extension Stack: Container {
    // 这一行可以不写
    // typealias ItemType = Element

    mutating func append(item: Element) {
        self.items.append(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

    在以上代码中,数组元素的类型为T,如果该类型并未提供compareTo域方法,将会导致编译错误,如何确保类型参数确实提供了compareTo方法呢?如果T是Comparable接口的实现类,那么该方法一定会被提供,因此可以通过Java语法中提供的类型参数限定的方式来确保这一点。见如下修订代码:

本文由必威发布于必威-编程,转载请注明出处:下面定义了一个普通类和一个泛型类必威,在J

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。