swift-- 协议

协议的基本⽤法

协议的语法格式

protocol MyProtocol{ 
 //body 
 }

我们熟悉的 class , struct , enum 都可以遵循协议，如果要遵守多个协议，使⽤逗号分隔。

struct Teacher: Protocol1, Protocol2{ 
//body 
 }

这⾥特别说⼀下，如果 class 中有 superClass ，⼀般我们放在遵循的协议之前

class Teacher: NSObject, Protocol1{ 
 //body 
}

协议中可以添加属性，⽤⼏个点需要注意⼀下：

• 协议同时要求⼀个属性必须明确是可读的或可读的和可写的
• 属性要求定义为变量属性

protocol MyProtocol{
    var age:Int {get}
    var time:Int{get set}
}
class myClass: MyProtocol {
    var time: Int = 0
    var age: Int {
        get{
            time * time
        }
    }
}

在协议中定义⽅法，我们只需要定义当前⽅法的名称，参数列表和返回值

protocol MyProtocol{
    func doSomething()
    //可能被结构体或者类继承 
    static func teach()
}
class myClass: MyProtocol {
    func doSomething() {
        print("doSomething")
    }
    
    static func teach() {
        print("teach")
    }
}

协议中也可以定义初始化⽅法，当我们实现初始化器的时候，必须使⽤ required 关键字

protocol MyProtocol{
    init(age:Int)
}
class myClass: MyProtocol {
    required init(age: Int) {
        print(age)
    }
}

如果想要协议只能被类准守，需要实现AnyObject

protocol MyProtocol:AnyObject

将协议作为类型

• 作为函数，⽅法或初始化程序中的参数类型或返回类型
• 作为常量，变量或属性的类型
• 作为数组，字典或其他容器中项⽬的类型

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

通过sil文件可以看到

  %10 = witness_method $@opened("5DA67B08-48DE-11EB-AA97-ACDE48001122") MyProtocol, #MyProtocol.teach!1 : <Self where Self : MyProtocol> (Self) -> () -> (), %9 : $*@opened("5DA67B08-48DE-11EB-AA97-ACDE48001122") MyProtocol : $@convention(witness_method: MyProtocol) <τ_0_0 where τ_0_0 : MyProtocol> (@in_guaranteed τ_0_0) -> () // type-defs: %9; user: %11
  %11 = apply %10<@opened("5DA67B08-48DE-11EB-AA97-ACDE48001122") MyProtocol>(%9) : $@convention(witness_method: MyProtocol) <τ_0_0 where τ_0_0 : MyProtocol> (@in_guaranteed τ_0_0) -> () // type-defs: %9


// protocol witness for MyProtocol.teach() in conformance Teacher
sil private [transparent] [thunk] @$s4main7TeacherCAA10MyProtocolA2aDP5teachyyFTW : $@convention(witness_method: MyProtocol) (@in_guaranteed Teacher) -> () {
// %0                                             // user: %1
bb0(%0 : $*Teacher):
  %1 = load %0 : $*Teacher                        // users: %2, %3
  %2 = class_method %1 : $Teacher, #Teacher.teach!1 : (Teacher) -> () -> (), $@convention(method) (@guaranteed Teacher) -> () // user: %3
  %3 = apply %2(%1) : $@convention(method) (@guaranteed Teacher) -> ()
  %4 = tuple ()                                   // user: %5
  return %4 : $()                                 // id: %5
} // end sil function '$s4main7TeacherCAA10MyProtocolA2aDP5teachyyFTW'

sil_vtable Teacher {
  #Teacher.teach!1: (Teacher) -> () -> () : @$s4main7TeacherC5teachyyF  // Teacher.teach()
  #Teacher.init!allocator.1: (Teacher.Type) -> () -> Teacher : @$s4main7TeacherCACycfC  // Teacher.__allocating_init()
  #Teacher.deinit!deallocator.1: @$s4main7TeacherCfD    // Teacher.__deallocating_deinit
}

sil_witness_table hidden Teacher: MyProtocol module main {
  method #MyProtocol.teach!1: <Self where Self : MyProtocol> (Self) -> () -> () : @$s4main7TeacherCAA10MyProtocolA2aDP5teachyyFTW   // protocol witness for MyProtocol.teach() in conformance Teacher
}

witness_method : 通过PWT （协议⽬击表）获取对应的函数地址.
在main函数中通过witness_table调用继承协议的实现找到vtable
如果把协议中的声明去掉

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

再次查看sil

 // function_ref MyProtocol.teach()
  %10 = function_ref @$s4main10MyProtocolPAAE5teachyyF : $@convention(method) <τ_0_0 where τ_0_0 : MyProtocol> (@in_guaranteed τ_0_0) -> () // user: %11
  %11 = apply %10<@opened("E3E7015A-48DF-11EB-8960-ACDE48001122") MyProtocol>(%9) : $@convention(method) <τ_0_0 where τ_0_0 : MyProtocol> (@in_guaranteed τ_0_0) -> () // type-defs: %9

直接调用了协议里的方法

PWT到底存放在哪里呢

protocol Shape{
 var area: Double{ get }
}
class Circle: Shape{
    var radious: Double
    init(_ radious: Double) {
        self.radious = radious
    }
    var area: Double{
        get{
            return radious * radious * 3.14
        }
    }
}
var circle:Shape = Circle.init(10.0)

swiftc -emit-ir main.swift | xcrun swift-demangle > ./main.ll && open main.ll

//操作的都是这个结构体
%T4main5ShapeP = type { [24 x i8], %swift.type*, i8** }

//将metadata放入
  store %swift.type* %4, %swift.type** getelementptr inbounds (%T4main5ShapeP, %T4main5ShapeP* @"main.circle : main.Shape", i32 0, i32 1), align 8
//将pwt放入
  store i8** getelementptr inbounds ([2 x i8*], [2 x i8*]* @"protocol witness table for main.Circle : main.Shape in main", i32 0, i32 0), i8*** getelementptr inbounds (%T4main5ShapeP, %T4main5ShapeP* @"main.circle : main.Shape", i32 0, i32 2), align 8
//将heapObject放入
  store %T4main6CircleC* %5, %T4main6CircleC** bitcast (%T4main5ShapeP* @"main.circle : main.Shape" to %T4main6CircleC**), align 8

用swift来模拟一下

protocol Shape{
 var area: Double{ get }
}
struct Circle: Shape{
    var radious: Double
    var radious1: Double = 20
    var radious2: Double = 30
//    var radious3: Double = 40
    init(_ radious: Double) {
        self.radious = radious
    }
    var area: Double{
        get{
            return radious * radious * 3.14
        }
    }
}

var circle:Shape = Circle.init(10.0)
//24字节
struct  protocolData {
    var value1:UnsafeRawPointer
    var value2:UnsafeRawPointer
    var value3:UnsafeRawPointer
    var type:UnsafeRawPointer
    var pwt:UnsafeRawPointer
}

withUnsafePointer(to: &circle, { ptr in
    ptr.withMemoryRebound(to: protocolData.self, capacity: 1, {point in
        print(point.pointee)
    })
})
·················
protocolData(value1: 0x4024000000000000, value2: 0x4034000000000000, value3: 0x403e000000000000, type: 0x0000000100003098, pwt: 0x0000000100003028)

通过实现可以发现如果我们在结构体Circle声明三个变量，就会分配存放在value1，value2，value3中,也就是valuebuffer中，超过3个属性，就会在value中开辟一个内存空间进行存放