Swift 进阶：协议 Protocol

Swift社区

发布于 2021-11-26 13:21:12

1.6K0

发布于 2021-11-26 13:21:12

文章被收录于专栏：Swift社区

1. 前言

本篇文章主要讲解 Swift 中常用的协议协议Protocol，主要分析protocol的用法及底层存储结构。

2. 基本用法

先来看看 Swift 中协议的基本用法（和 OC 的差别不大）👇

▐ 2.1 语法格式

协议的语法格式👇

protocol MyProtocol {
    // body
}

class、struct、enum都可以遵守协议，如果需要遵守多个协议，可以使用逗号分隔，例如👇

struct LGTeacher: Protocol1, Protocol2 {
    // body
}

如果 class 中有superClass，一般是放在遵守的协议之前👇

struct LGTeacher: NSObject, Protocol1, Protocol2 {
    // body
}

▐ 2.2 协议中的属性

再来看看协议中的属性，需要注意2点👇

协议同时要求一个属性必须明确是可读的/可读可写的
属性要求定义为变量类型,即使用var而不是let

protocol LGTestProtocol {
    var age: Int {get set}
}

▐ 2.3 协议中的方法

最后看看协议中的方法，和 OC 一样，只需声明不需实现。例如👇

protocol MyProtocol {
    func doSomething()
    static func teach()
}

然后类遵循了该协议，必须实现协议中的方法👇

class LGTeacher: MyProtocol{
    func doSomething() {
        print("LGTeacher doSomething")
    }
    
    static func teach() {
        print("LGTeacher teach")
    }
}
var t = LGTeacher()
t.doSomething()
LGTeacher.teach()

协议中也可以定义初始化方法，当实现初始化器时，必须使用required关键字( OC 不需要)👇

protocol MyProtocol {
    init(age: Int)
}
class LGTeacher: MyProtocol {
    var age: Int
    required init(age: Int) {
        self.age = age
    }
}

如果一个协议只能被类实现，需要协议继承AnyObject。如果此时结构体遵守该协议，会报错！👇

3. 进阶用法

协议的进阶用法 👉 将协议作为类型，主要有以下3种情况👇

作为函数、方法或者初始化程序中的参数类型或者返回值
作为常量、变量或属性的类型
作为数组、字典或者其他容器中元素 Item 的类型

▐ 3.1 继承的方式

先看看，下面的代码输出结果是什么？👇

class Shape{
    var area: Double{
        get{
            return 0
        }
    }
}
class Circle: Shape{
    var radius: Double
   
    init(_ radius: Double) {
        self.radius = radius
    }
    
    override var area: Double{
        get{
            return radius * radius * 3.14
        }
    }
}
class Rectangle: Shape{
    var width, height: Double
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }
    
    override var area: Double{
        get{
            return width * height
        }
    }
}

var circle: Shape = Circle.init(10.0)
var rectangle: Shape = Rectangle.init(10.0, 20.0)

var shapes: [Shape] = [circle, rectangle]
for shape in shapes{
    print(shape.area)
}

上面的代码是基于继承的方式来实现的，基类中的area必须有一个默认实现。当然，这种情况也可以采用协议的方式来实现👇

▐ 3.1 协议的方式

protocol Shape {
    var area: Double {get}
}
class Circle: Shape{
    var radius: Double

    init(_ radius: Double) {
        self.radius = radius
    }

    var area: Double{
        get{
            return radius * radius * 3.14
        }
    }
}
class Rectangle: Shape{
    var width, height: Double
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

var circle: Shape = Circle.init(10.0)
var rectangle: Shape = Rectangle.init(10.0, 20.0)

var shapes: [Shape] = [circle, rectangle]
for shape in shapes{
    print(shape.area)
}

shape变成了协议，提供了一个只读属性area，遵循该协议的类都要实现 age 的get方法。接着我们再来看var shapes 👉 里面的元素存在2种情况👇

元素指定的Shape是类时，数组中存储的都是引用类型的地址(这一点很好理解，没问题)
元素指定的Shape是协议时，数组中存储的是什么?

那如何让数组 shapes 里的元素是协议？👉 让协议默认实现 area 的 get 方法👇

protocol Shape {

}

extension Shape{
    var area: Double {
        get{return 0}
    }
}

然后，我们这么调用，看看输出什么？👇

var circle: Shape = Circle.init(10.0)
print(circle.area)

输出是0.0，为什么不是10*10*3.14？因为在协议Shape的extension中，声明的方法是静态调用，那么在编译期间代码的地址就定下来了，是无法改变的，这点我们可以用SIL代码来验证👇

首先看看main函数

再看看协议shape协议extension中实现的area的get方法👇

上图 SIL 代码中可以看出，Circle.init(10.0)初始化里虽然传递的是10.0，但是SIL代码中初始化确使用的是Builtin.FPIEEE64，而Builtin.FPIEEE64恰巧是shape协议extension中实现的area的get方法的返回值（即是0），最后我们再练看看circle.area 方法源码👇

调用的也是$Builtin.FPIEEE64 👉 0.0，所以print(circle.area)输出当然是0.0。

4. 底层原理

我们先来看看下面的案例输出什么？👇

protocol MyProtocol {
    func teach()
}
extension MyProtocol{
    func teach(){ print("MyProtocol") }
}
class MyClass: MyProtocol{
    func teach(){ print("MyClass") }
}
let object: MyProtocol = MyClass()
object.teach()
let object1: MyClass = MyClass()
object1.teach()

为什么输出的结果一样呢？老规矩，从 SIL 分析👇

▐ 4.1 示例SIL分析

部分一 👉 MyProtocol 和 MyClass的定义

部分二 👉 main函数中的调用

从上图中我们知道👇

对象 object 👉 方法 teach 的调用是通过witness_method调用
而对象 object1 👉 方法 teach 的调用是通过class_method调用

接着我们在SIL代码中分别搜索#MyProtocol.teach和#MyClass.teach👇

发现了两个方法列表：MyClass的sil_vtable和sil_witness_table：

sil_vtable这个我们很熟悉，之前的Swift 值类型引用类型 & 方法调度文章提过，就是类MyClass的函数列表
sil_witness_table对应的就是Protocol Witness Table(简称PWT)，里面存储的是方法数组，里面包含了方法实现的指针地址，一般我们调用方法时，是通过获取对象的内存地址和方法的位移offset去查找的。

而sil_witness_table里面其实调用的还是 MyClass 的 teach 方法👇

这也是为什么object.teach()输出的是MyClass的原因。

扩展：去掉Protocol中声明的方法

//如果去掉协议中的声明呢？打印结果是什么
protocol MyProtocol {
}
extension MyProtocol{
    func teach(){ print("MyProtocol") }
}
class MyClass: MyProtocol{
    func teach(){ print("MyClass") }
}
let object: MyProtocol = MyClass()
object.teach()

let object1: MyClass = MyClass()
object1.teach()

继续 SIL 分析👇

MyProtocol 没有了 teach 函数的声明👇

main函数调用

上图可知👇

第一个打印 MyProtocol，是因为调用的是协议扩展中的 teach 方法，这个方法的地址是在编译时期就已经确定的，即通过静态函数地址调度
第二个打印 MyClass，同上个例子一样，是类的函数表调用

方法列表

上图可知，查看 SIL 中的 witness_table，其中已经没有teach方法，因为👇

声明在Protocol中的方法，在底层会存储在PWT，PWT中的方法也是通过class_method，去类的V-Table中找到对应的方法的调度。
如果没有声明在Protocol中的函数，只是通过Extension提供了一个默认实现，其函数地址在编译过程中就已经确定了，对于遵守协议的类来说，这种方法是无法重写的。

▐ 4.2 协议的PWT存储位置

我们在分析函数调度时，已经知道了V-Table是存储在metadata中的，而且根据上面的分析，协议中的方法存储在PWT，那PWT存储在哪里呢？接下来我们来探究一下。首先我们来看看下面的示例，输出什么？👇

protocol Shape {
    var area: Double {get}
}
class Circle: Shape{
    var radius: Double

    init(_ radius: Double) {
        self.radius = radius
    }

    var area: Double{
        get{
            return radius * radius * 3.14
        }
    }
}

var circle: Shape = Circle(10.0)
print(MemoryLayout.size(ofValue: circle))
print(MemoryLayout.stride(ofValue: circle))

var circle1: Circle = Circle(10.0)
print(MemoryLayout.size(ofValue: circle1))
print(MemoryLayout.stride(ofValue: circle1))

circle 的类型是协议Shape，而 circle1 的类型是类Circle，输出结果👇

circle 的size和stride均为40，why？

首先 lldb 看看👇

circle首地址的metadata地址中，heapObject里保存了10这个值。

接着看看 SIL (main函数代码）👇

我们发现，SIL 中，系统是通过调用init_existential_addr读取之前声明的 circle 变量，而 circle1 却是👇

circle是通过调用 load 指令读取的，那么init_existential_addr这个指令代表什么意思呢？我们去 SIL 官网说明文档，查到👇

上图中的existential container是编译器生成的一种特殊的数据类型，也用于管理遵守了相同协议的协议类型。因为这些数据类型的内存空间尺寸不同，使用existential container进行管理可以实现存储一致性。

所以，系统使用existential container容器包含了Shape类型，接着调用existential container这个类型来初始化circle变量，相当于对circle包装了一层。那么，重点就来到了existential container，接下来我们通过 IR 代码，看看这个容器中存储的数据格式是什么样的？

继续查看 IR 代码👇

接着看 main 函数代码👇

也就是最终结构是{ heapObject, metadata, PWT }，这和之前 lldb 查看的内存分布一模一样！

仿写

接下来，我们可以尝试仿写 IR 的 main 函数这块内存绑定的流程，代码👇

// HeapObject结构体(Swift类的本质)
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}
// %T4main5ShapeP = type { [24 x i8], %swift.type*, i8** }
struct protocolData {
    //24 * i8 ：因为是8字节读取，所以写成3个指针，正好24字节
    var value1: UnsafeRawPointer
    var value2: UnsafeRawPointer
    var value3: UnsafeRawPointer
    //type 存放metadata，目的是为了找到Value Witness Table 值目录表
    var type: UnsafeRawPointer
    // i8* 存放pwt，即协议的方法列表
    var pwt: UnsafeRawPointer
}
// 2、定义协议+类
protocol Shape {
    var area: Double {get}
}
class Circle: Shape{
    var radius: Double

    init(_ radius: Double) {
        self.radius = radius
    }

    var area: Double{
        get{
            return radius * radius * 3.14
        }
    }
}
//对象类型为协议
var circle: Shape = Circle(10.0)

// 3、将circle强转为protocolData结构体
withUnsafePointer(to: &circle) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

运行👇

至此，我们知道了PWT的存储位置👇

存储在一个existential container容器中，该容器的大致结构是{ heapObject, metadata, PWT }

修改一：将class改成 struct

我们再定义一个结构体Rectangle，也遵循Shape协议👇

protocol Shape {
    var area: Double {get}
}
struct Rectangle: Shape{
    var width, height: Double
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}
//对象类型为协议
var rectangle: Shape = Rectangle(10.0, 20.0)

struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}
// %T4main5ShapeP = type { [24 x i8], %swift.type*, i8** }
struct protocolData {
    //24 * i8 ：因为是8字节读取，所以写成3个指针
    var value1: UnsafeRawPointer
    var value2: UnsafeRawPointer
    var value3: UnsafeRawPointer
    //type 存放metadata，目的是为了找到Value Witness Table 值目录表
    var type: UnsafeRawPointer
    // i8* 存放pwt
    var pwt: UnsafeRawPointer
}

//将circle强转为protocolData结构体
withUnsafePointer(to: &rectangle) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

Rectangle有2个成员width和height，所以protocolData中的 value1 和 value2 分别存储着他们的值👇

接下来我们看看 IR 代码中是怎么处理的👇

上图可知，width所对应的%4是从0开始偏移存储8字节，那么就是0~7，而height对应的5%是从1开始的，就是8~15。(如果Rectangle是类class的话，应该都是存储在0~7，因为存储的是HeapObject)

修改二：struct中有3个属性

继续修改，再添加一个属性，变成3个属性呢？👇

struct Rectangle: Shape{
    var width, height: Double
    var width1 = 30.0
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

从结果中可以看出，width1是存储在value3。

修改三：struct中有4个属性

继续，4个属性呢？👇

struct Rectangle: Shape{
    var width, height: Double
    var width1 = 30.0
    var height1 = 40.0
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

我们再看看 value1 的地址👇

小结

所以Protocol协议在底层的存储结构👇

前24个字节，主要用于存储遵循了协议的class/struct的属性值，如果24字节不够存储，会在堆区开辟一个内存空间，然后在24字节中的前8个字节存储该堆区地址（超出24字节是直接分配堆区空间，然后存储值，并不是先存储值，然后发现不够再分配堆区空间）
后16个字节分别用于存储vwt（值目录表）、pwt（协议目录表）

▐ 4.3 写时复制（copy on write）

继续修改例子，将Rectangle改为class，声明一个数组存储circle 和 rectangle对象👇

protocol Shape {
    var area: Double {get}
}
class Circle: Shape{
    var radius: Double

    init(_ radius: Double) {
        self.radius = radius
    }

    var area: Double{
        get{
            return radius * radius * 3.14
        }
    }
}
class Rectangle: Shape{
    var width, height: Double
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

var circle: Shape = Circle.init(10.0)
var rectangle: Shape = Rectangle.init(10.0, 20.0)

var shapes: [Shape] = [circle, rectangle]

for shape in shapes{
    print(shape.area)
}

我们知道，protocol 中存储了 pwt，pwt 的内部也是通过class_method查找，在代码运行过程中，底层通过容器结构体，将metadata和pwt关联起来，所以可以根据metadata找到对应的v-table，从而完成方法的调用。所以，上图中输出的 314 和 200 就说明了 👉 系统是去各自的类中查找属性 area 的 get 方法。

再看下面的示例👇（将Rectangle还原回结构体，然后再声明一个变量 rectangle1 = rectangle）

struct Rectangle: Shape{
    var width, height: Double
    var width1 = 30.0
    var height1 = 40.0
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

//对象类型为协议
var rectangle: Shape = Rectangle(10.0, 20.0)
//将其赋值给另一个协议变量
var rectangle1: Shape  = rectangle

然后使用withMemoryRebound绑定值到结构体protocolData中查看内存👇

// 查看其内存地址
struct HeapObject {
    var type: UnsafeRawPointer
    var refCount1: UInt32
    var refCount2: UInt32
}
// %T4main5ShapeP = type { [24 x i8], %swift.type*, i8** }
struct protocolData {
    //24 * i8 ：因为是8字节读取，所以写成3个指针
    var value1: UnsafeRawPointer
    var value2: UnsafeRawPointer
    var value3: UnsafeRawPointer
    //type 存放metadata，目的是为了找到Value Witness Table 值目录表
    var type: UnsafeRawPointer
    // i8* 存放pwt
    var pwt: UnsafeRawPointer
}

withUnsafePointer(to: &rectangle) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

withUnsafePointer(to: &rectangle1) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

从输出结果来看，两个协议变量rectangle和rectangle1内存地址是一模一样的。如果修改rectangle1的width属性的值（需要将width属性声明到protocol）👇

protocol Shape {
    var width: Double {get set}
    var area: Double {get}
}

调用代码👇

withUnsafePointer(to: &rectangle) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}
withUnsafePointer(to: &rectangle1) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

rectangle1.width = 50.0
withUnsafePointer(to: &rectangle1) { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1) { pointer in
        print(pointer.pointee)
    }
}

修改前 rectangle和rectangle1的heapObject也就是value1相同0x00000001005421b0，修改后rectangle1的heapobject变成了0x0000000100611720。这里也就验证了struct值类型（虽然超过了24字节存储到了堆上）【写时赋值】👇

当复制时，并没有值的修改，所以两个变量指向同一个堆区内存，当第二个变量修改了属性值时，会将原本堆区内存的值拷贝到一个新的堆区内存，并进行值的修改

如果将struct值类型改为class引用类型，结果会怎样？

class Rectangle: Shape{
    var width: Double
    var height: Double
    var width1 = 30.0
    var height1 = 40.0
    init(_ width: Double, _ height: Double) {
        self.width = width
        self.height = height
    }

    var area: Double{
        get{
            return width * height
        }
    }
}

上图可知，修改前后，地址没有发生任何变化！

Value Buffer

struct结构体中24字节官方叫法是Value Buffer。
Value Buffer用来存储当前的值，如果超过存储的最大容量的话会开辟一块堆空间。
针对值类型来说在赋值时会先拷贝 heapobject 地址（Copy on write）。在修改时会先检测引用计数，如果引用计数大于1，此时开辟新的堆空间把要修改的内容拷贝到新的堆空间（这么做为了提升性能）。

Value Buffer在容器existential container中的位置👇

总结

本篇文章讲解了Swift中有一个重要的概念 👉 协议Protocol，从基础概念、用法，进阶用法和底层这条主线，详细讲解了值类型struct与引用类型class遵循协议时，其PWT和Value Buffer的内存地址的分布，希望大家掌握，从容应对面试。

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-04-27，如有侵权请联系 cloudcommunity@tencent.com 删除

存储

html

本文分享自 Swift社区微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

存储

html

登录后参与评论

0 条评论

热度