1.方法调用
对于结构体中的⽅法都是静态调⽤（直接调⽤），那对于类⽐的 class 中的⽅法那？我们类中声明的⽅法 是通过 V-table 来进⾏调度的。
1.1结构体方法调用
struct MyStruct {
func method1() {
print("method1")
}
func method2() {
print("method2")
}
}
let myStruct = MyStruct()
myStruct.method1()
我们看断点
1.2类实例方法调用
我们定义如下类
class PWTeacher {
func method1() {
print("method1")
}
func method2() {
print("method2")
}
func method3() {
print("method3")
}
}
查看sil文件
sil_vtable PWTeacher {
#PWTeacher.method1: (PWTeacher) -> () -> () : @main.PWTeacher.method1() -> () // PWTeacher.method1()
#PWTeacher.method2: (PWTeacher) -> () -> () : @main.PWTeacher.method2() -> () // PWTeacher.method2()
#PWTeacher.method3: (PWTeacher) -> () -> () : @main.PWTeacher.method3() -> () // PWTeacher.method3()
#PWTeacher.init!allocator: (PWTeacher.Type) -> () -> PWTeacher : @main.PWTeacher.__allocating_init() -> main.PWTeacher // PWTeacher.__allocating_init()
#PWTeacher.deinit!deallocator: @main.PWTeacher.__deallocating_deinit // PWTeacher.__deallocating_deinit
}
我们创建实例，并调用方法，通过断点看调用
let t = PWTeacher()
t.method1()
t.method2()
t.method3()
通过汇编调试，我们可以看出在结构体调用方法时，是直接call地址，而类实例调用方法时，则是通过偏移找到方法在vtable的位置，然后再call调用。我们可以看出method1，method2，method3，在偏移时，之间相差8字节。
extension的调用方式呢
extension PWTeacher {
func method4() {
print("method4")
}
}
let t = PWTeacher()
t.method4()
我们通过汇编调试，看一下
extension中的方法调用和struct中的方法调用是一样的都是直接调用。
1.3.方法关键字
final 关键字修饰方法
我们调用final修饰的方法，从汇编看出是直接调用，从sil文件可以看到vtable文件没有被final修饰的方法。
@objc修饰方法
调用还是在vtable中通过偏移找到函数指针进行调用的
在sil中我们可以看到
经过@objc修饰的函数在sil中会生成两个函数，一个供swift调用，一个供OC调用，但是供OC函数内还是调用供的swift调用的函数。
swfit类继承NSObject，
我们在oc中可以访问,方法属性如果添加@objc，oc内也可以访问
class PWTeacher :NSObject{
@objc var age:Int = 10
@objc func teachMethod(){
print("teachMethod")
}
}
我们可以在项目-Swift.h文件中看到
SWIFT_CLASS("_TtC10OCAndSwift9PWTeacher")
@interface PWTeacher : NSObject
@property (nonatomic) NSInteger age;
- (void)teachMethod;
- (nonnull instancetype)init OBJC_DESIGNATED_INITIALIZER;
@end
dynamic关键字
class PWTeacher {
dynamic func method1() {
print("method2")
}
}
let t = PWTeacher()
t.method1()
swift调用的时候，还是调用vtable方法表，
dynamic加@objc关键字
class PWTeacher {
@objc dynamic func method1() {
print("method2")
}
}
let t = PWTeacher()
t.method1()
我们看汇编
经过objc dynamic修饰的，方法调用objc_msgSend
dynamic加@_dynamicReplacement
class PWTeacher {
dynamic func method() {
print("method")
}
}
extension PWTeacher {
@_dynamicReplacement(for:method)
func method1() {
print("method1")
}
}
let t = PWTeacher()
t.method()
t.method1()
打印结果
method1
method1
调用method时，实质是调用的method1。调用method1和原先不变。
1.4.补充arm64下的汇编指令
blr ; 带返回的跳转指令，跳转到指令后边跟随寄存器中保存的地址
mov: 将某⼀寄存器的值复制到另⼀寄存器(只能⽤于寄存器与寄存器或者寄存器 与常量之 间传值，不能⽤于内存地址)，如: 6 mov x1, x0 将寄存器 x0 的值复制到寄存器 x1 中
ldr: 将内存中的值读取到寄存器中，如: 9 ldr x0, [x1, x2] 将寄存器 x1 和寄存器 x2 相加作为地址，取该内存 地址的值放⼊寄存器 x0 中
str : 将寄存器中的值写⼊到内存中，如: 12 str x0, [x0, x8] ， 将寄存器 x0的值保存到内存[x0 + x8]处
bl: 跳转到某地址
2.指针
原始指针的使用
let p = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 8)
for i in 0..<4 {
p.advanced(by: i*8).storeBytes(of: i+1, as: Int.self)
}
for i in 0..<4 {
let value = p.load(fromByteOffset: i*8, as: Int.self)
print(value)
}
p.deallocate()
allocate:分配32字节的内存大小
advanced：代表当前p前进的步长，对于RawPointer来说，我们需要移动的是
withUnsafePointer的使用
var age = 18
age = withUnsafePointer(to: &age){
ptr in
ptr.pointee + 12
}
print(age)
能正常打印
如果我们想在内部修改ptr的值则可以使用withUnsafeMutablePointer
var age = 18
withUnsafeMutablePointer(to: &age){
ptr in
ptr.pointee += 12
}
print(age)
打印结果是30
UnsafeMutablePointer的使用
var ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1);
ptr.initialize(to: 20)
ptr.deinitialize(count: 1)
ptr.deallocate()
print(ptr.pointee)
allocate和deallocate，initialize和deinitialize是成对出现的
结构体指针的使用
struct PWPerson {
var age = 18
var height = 180
}
var ptr = UnsafeMutablePointer<PWPerson>.allocate(capacity: 2)
ptr.initialize(to: PWPerson())
ptr.advanced(by: 1).initialize(to: PWPerson(age: 20, height: 190))
//方法1访问
print(ptr[0])
print(ptr[1])
//方法2访问
print(ptr.pointee)
print((ptr+1).pointee)
//方法3访问
print(ptr.pointee)
print(ptr.successor().pointee)
ptr.deinitialize(count: 2)
ptr.deallocate()
在advanced中因为我们知道类型所以知道一次要移动的字节数，所以我们在这里写1，2，3等步数，
而UnsafeMutableRawPointer移动的是字节数，因为不知道步长是多少。
swift实例转化成结构体
class PWTeacher {
var age:Int = 18
}
struct HeapObject {
var kind:UnsafeRawPointer
var strongRef:UInt32
var unownedRed :UInt32
}
struct lg_swift_class {
var kind: UnsafeRawPointer
var superClass: UnsafeRawPointer
var cachedata1: UnsafeRawPointer
var cachedata2: UnsafeRawPointer
var data: UnsafeRawPointer
var flags: UInt32
var instanceAddressOffset: UInt32
var instanceSize: UInt32
var flinstanceAlignMask: UInt16
var reserved: UInt16
var classSize: UInt32
var classAddressOffset: UInt32
var description: UnsafeRawPointer
}
var t = PWTeacher()
//Unmanaged 类似于OC和CF所有权的转换
let ptr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
//ptr获得的指针类型为UnsafeMutableRawPointer
//通过bindMemory，从RawPointer转换成UnsafeMutablePointer，
let heapPoiner = ptr.bindMemory(to: HeapObject.self, capacity: 1)
let metaPtr = heapPoiner.pointee.kind.bindMemory(to: lg_swift_class.self, capacity: 1)
print(metaPtr.pointee)
总结：
Unmanaged.passUnretained是把一个UnsafePointer(UnsafeMutablePointer)类型的指针转成UnsafeMutableRawPointer
ptr.bindMemory:是UnsafeMutableRawPointer指针绑定为UnsafePointer(UnsafeMutablePointer)指针，如果ptr已经是UnsafePointer(UnsafeMutablePointer)则重新绑定
bindMemory(to: Capacity:) : 更改内存绑定的类型，如果之前没有绑定，那么就是⾸次绑定；如果绑 定过了，会被重新绑定为该类型
UnsafePointer类型的转换 UnsafePointer<(Int,Int)>转化成UnsafePointer<Int>
var tul = (10,12)
func test(ptr:UnsafePointer<Int>){
print(ptr.pointee)
}
withUnsafePointer(to: &tul) {
(tulPtr:UnsafePointer<(Int,Int)>) in
test(ptr: UnsafeRawPointer(tulPtr).assumingMemoryBound(to: Int.self))
}
assumingMemoryBound: 假定内存绑定，这⾥是告诉编译器：哥们我就是这种类型，你不要检查我 了
withMemoryRebound UnsafePointer<Int>转化成UnsafePointer<UInt64 >
var age = 10
func test(ptr:UnsafePointer<UInt64>) {
print(ptr.pointee)
}
withUnsafePointer(to: &age) { (ptr:UnsafePointer<Int>) in
test(ptr: ptr.withMemoryRebound(to: UInt64.self, capacity: 1){$0})
}
