Swift 中类与结构体（一）

2021-12-29 本文已影响0人晨曦的简书

这里我们主要通过三个方面来阐述类与结构体的区别，首先是类与结构体的区别以及它们之间的相同点。第二点就是了解类的初始化器的规则，以便于我们写出相对 swift 的代码。第三点是介绍类的生命周期，主要是对类在内存结构及数据结构的探索。

初识类与结构体

类的示例代码

class CXPerson {
  var age: Int 
  var name: String

  init(age: Int, name: String) {
    self.age = age
    self.name = name 
  }

  deinit{}
}

结构体的示例代码

struct CXPerson {
  var age: Int 
  var name: String

  init(age: Int, name: String) {
    self.age = age
    self.name = name 
  }

  deinit{}
}

结构体和类的主要相同点有:

定义存储值的属性
定义方法
定义下标以使用下标语法提供对其值的访问
定义初始化器
使用 extension 来拓展功能
遵循协议来提供某种功能

主要的不同点有:

类有继承的特性，而结构体没有
类型转换使您能够在运行时检查和解释类实例的类型  类有析构函数用来释放其分配的资源
引用计数允许对一个类实例有多个引用

对于类与结构体我们需要区分的第一件事就是:

类是引用类型。也就意味着一个类类型的变量并不直接存储具体的实例对象，是对当前存储具体实例内存地址的引用。

var t1 = t

这里我们借助两个指令来查看当前变量的内存结构:

po : p 和 po 的区别在于使用 po 只会输出对应的值，而 p 则会返回值的类型以及命令结果的引用名。

x/8g: 读取内存中的值(8g: 8字节格式输出)

swift 中有引用类型，也有值类型，最典型的就是 Struct，结构体的定义也非常简单，相比较引用类型的变量中存储的是地址，那么值类型存储的就是具体的实例(或者说具体的值)。

struct LGStudent {
  var age: Int
  var name: String
}
var s = LGStudent(age:18, name:kody) var 
s1 = s

其实引用类型就相当于在线的 Excel，当我们把这个链接共享给别人的时候，别人的修改我们是能够看到的;值类型就相当于本地的 Excel，当我们把本地的 Excel 传递给别人的时候，就相当于重新复制了一份给别人，至于他们对于内容的修改我们是无法感知的。

另外引用类型和值类型还有一个最直观的区别就是存储的位置不同，一般情况，值类型存储在栈上，引用类型存储在堆上。

首先我们对内存区域来一个基本概念的认知

栈区(stack): 局部变量和函数运行过程中的上下文

//test是不是一个函数 
func test(){
  //我们在函数内部声明的age变量是不是就是一个局部变量 
  var age: Int = 10
  print(age)
}

这里 age 变量就是存在于栈区。

Heap: 存储所有对象
Global: 存储全局变量;常量;代码区
Segment & Section: Mach-O 文件有多个段( Segment)，每个段有不同的功能。然后每个段又分为很多小的 Section。

TEXT.text : 机器码
TEXT.cstring : 硬编码的字符串
TEXT.const: 初始化过的常量
DATA.data: 初始化过的可变的(静态/全局)数据 DATA.const: 没有初始化过的常量
DATA.bss: 没有初始化的(静态/全局)变量
DATA.common: 没有初始化过的符号声明

我们来看例子：

struct CXTeacher{ 
  var age = 18
  var name = "ChenXi" 
}
func test() {
  var t = CXTeacher() 
}
test()

接下来使用命令:

// 一个 lldb 调试命令
frame varibale -L xxx

通过调试命令可以打印出 t 的内存结构，t 存储于栈区。

下面我们再来看一种结构体中存在类对象属性的情况下的内存分布：

这里可以看到 p 变量仍然存在于栈区，只是 p 变量中存储的地址需要在堆空间中开辟。但是并不会影响结构体的存储位置。

如果我们把其他条件不变，将 strcut 修改成 class 的情况我们来看一下:

这里可以看到，t 存在于堆空间，对于 var t = CXTeacher() 这句代码会分为三步，首先会在栈上开辟 8 字节的空间用来存储堆区的地址，第二步执行 CXTeacher() 初始化的时候会在堆空间寻找合适的内存区域，并把地址返回，第三步就是把 value 的值拷贝到刚开辟的堆空间，并把刚返回的堆地址存储到栈上刚开辟的 8 字节空间内。当离开作用域之后堆内存会被销毁，销毁的过程就是查找并把内存块重新插入到堆空间中，对于堆空间来说始终都要有一个查找的过程，并且与此同时要销毁栈上的指针。栈于堆在分配内存的过程中会有时间与速度上的区别。这里我们也可以通过 github 上 StructVsClassPerformance 这个案例来直观的测试当前结构体和类在内存分配时时间上的区别。

// 1 field
class IntClass {
    let value: Int
    init(_ val: Int) { self.value = val }
}

struct IntStruct {
    let value: Int
    init(_ val: Int) { self.value = val }
}

func + (x: IntClass, y: IntClass) -> IntClass {
    return IntClass(x.value + y.value)
}

func + (x: IntStruct, y: IntStruct) -> IntStruct {
    return IntStruct(x.value + y.value)
}

// 10 fields
class Int10Class {
    let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
    
    init(_ val: Int) {
        self.value1 = val
        self.value2 = val
        self.value3 = val
        self.value4 = val
        self.value5 = val
        self.value6 = val
        self.value7 = val
        self.value8 = val
        self.value9 = val
        self.value10 = val
    }
}

struct Int10Struct {
    let value1, value2, value3, value4, value5, value6, value7, value8, value9, value10: Int
    
    init(_ val: Int) {
        self.value1 = val
        self.value2 = val
        self.value3 = val
        self.value4 = val
        self.value5 = val
        self.value6 = val
        self.value7 = val
        self.value8 = val
        self.value9 = val
        self.value10 = val
    }
}

func + (x: Int10Struct, y: Int10Struct) -> Int10Struct {
    return Int10Struct(x.value1 + y.value1)
}

func + (x: Int10Class, y: Int10Class) -> Int10Class {
    return Int10Class(x.value1 + y.value1)
}

class Tests {
    static func runTests() {
        print("Running tests")
        
        measure("class (1 field)") {
            var x = IntClass(0)
            for _ in 1...10000000 {
                x = x + IntClass(1)
            }
        }
        
        measure("struct (1 field)") {
            var x = IntStruct(0)
            for _ in 1...10000000 {
                x = x + IntStruct(1)
            }
        }
        
        measure("class (10 fields)") {
            var x = Int10Class(0)
            for _ in 1...10000000 {
                x = x + Int10Class(1)
            }
        }
        
        measure("struct (10 fields)") {
            var x = Int10Struct(0)
            for _ in 1...10000000 {
                x = x + Int10Struct(1)
            }
        }
    }
    
    static private func measure(_ name: String, block: @escaping () -> ()) {
        print()
        print("\(name)")
        let t0 = CACurrentMediaTime()
        
        block()
        
        let dt = CACurrentMediaTime() - t0
        print("\(dt)")
    }
}

可以看到，不管是有一个成员变量的时候还是有10个成员变量的时候，结构体的内存分配需要的时间都比类要少的多，所以如果只需要数据结构来描述当前的数据类型的话优先选择结构体，而且结构体是存在于栈区，所以是线程安全的。下面我们再来看两个官方案例。

案例一

enum Color { case blue, green, gray }
enum Orientation { case left, right }
enum Tail { case none, tail, bubble }

var cache = [String : UIImage]()
func makeBalloon(_ color: Color, orientation: Orientation, tail: Tail) -> UIImage {
    let key = "\(color):\(orientation):\(tail)"
    if let image = cache[key] {
        return image
    }
}

这里是一个获取聊天气泡的案例，在 makeBalloon 方法中，key 是一个拼接的字符串，虽然可以通过 key 来获取到缓存，但是因为 key 是 String 类型，存在于堆空间，所以仍然要不停的进行内存的销毁于创建，如果这样的话，这样的效率对于聊天界面来说的话是不太好的，所以要进行优化，提高代码的执行效率。

优化后代码：

struct Balloon: Hashable {
  var color: Color
  var orientation: Orientation
  var tail: Tail
}

var cache = [Balloon : UIImage]()
func makeBalloon(_ balloon: Balloon) -> UIImage {
  if let image = cache[balloon] {
    return image
  }
}

优化之后，我们通过 Balloon 来作为 key，这样的话就避免了堆上内存的销毁与创建，执行效率就会大大提高。

案例二

struct Attachment {
  let fileURL: URL
  let uuid: String
  let mineType: String
  init?(fileURL: URL, uuid: String, mimeType: String) {
    self.fileURL = fileURL
    self.uuid = uuid
    self.mineType = mimeType
  }
}

这里通过结构体作为存储信息的模型，但是结构体中的成员变量还都是 class 类型，是引用类型，都需要在堆区分配内存空间，这样的话在内存分配及引用计数的层面消耗会比较大，这里就可以针对这些进行优化。

优化后：

enum MimeType: String {
    case jpeg = "image/jpeg"
}

struct Attachment {
    let fileURL: URL
    let uuid: UUID
    let mineType: MimeType
    init?(fileURL: URL, uuid: UUID, mimeType: MimeType) {
        guard mimeType is MimeType
        else { return nil }
        self.fileURL = fileURL
        self.uuid = uuid
        self.mineType = mimeType
    }
}

这里除了 fileURL 类型没法用值类型来替代，我们把 uuid 跟 mimeType 都改为了值类型，这样就降低了在内存分配过程中的资源消耗。

类的初始化器

需要注意的一点是:当前的类编译器默认不会自动提供成员初始化器，但是对于结构体来说编译
器会提供默认的初始化方法（前提是我们自己没有指定初始化器）！

struct CXPerson {
    var name: String
    var age: Int
}

我们创建结构体的时候，编译器也会有提示。

Swift 中创建类和结构体的实例时必须为所有的存储属性设置一个合适的初始值。所以类 CXPerson 必须要提供对应的指定初始化器，同时我们也可以为当前的类提供便捷初始化器(注意:便捷初始化器必须从相同的类里调用另一个初始化器。)。当我们定义一个类的时候可能会定义很多初始化器，但是当我们想把控所有初始化器入口，并做统一配置的时候就可以采用这种方式，只定义一种指定初始化器，其他的初始化器都采用便捷初始化器，所有的便捷初始化器都需要调用指定初始化器。

class CXPerson {
    var name: String
    var age: Int
    init(_ name: String, _ age: Int) {
        self.name = name
        self.age = age
    }
    
    convenience init() {
        self.init("chenxi", 18)
    }
}

当我们派生出一个子类 CXTeacher , 并定义一个指定初始化器:

class CXPerson {
    var age: Int
    var name: String
    init(_ age: Int, _ name: String) {
        self.age = age
        self.name = name
    }
    
    convenience init() {
        self.init(18, "chenxi")
    }
}

class CXTeacher: CXPerson {
    var subjectName: String
    init(subjectName: String) {
        self.subjectName = subjectName
        super.init(18, "chenxi")
    }
}

初始化器需要遵循以下规则：

指定初始化器必须保证在向上委托给父类初始化器之前，其所在类引入的所有属性
都要初始化完成。
指定初始化器必须先向上委托父类初始化器，然后才能为继承的属性设置新值。如
果不这样做，指定初始化器赋予的新值将被父类中的初始化器所覆盖
便捷初始化器必须先委托同类中的其它初始化器，然后再为任意属性赋新值(包括同类里定义的属性)。如果没这么做，便捷构初始化器赋予的新值将被自己类中其
它指定初始化器所覆盖。
初始化器在第一阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例
属性的值，也不能引用 self 作为值。

可失败初始化器: 这个也非常好理解，也就意味着当前因为参数的不合法或者外部条件的不满足，存在初始化失败的情况。这种 Swift中可失败初始化器写 return nil 语句，来表明可失败初始化器在何种情况下会触发初始化失败。写法也非常简单，这里我们判断 age 小于 18 就返回 nil。

class CXPerson {
    var age: Int
    var name: String
    init?(_ age: Int, _ name: String) {
        if (age < 18) {return nil}
        self.age = age
        self.name = name
    }
    
    convenience init?() {
        self.init(18, "chenxi")
    }
}

必要初始化器: 在类的初始化器前添加 required 修饰符来表明所有该类的子类都必须实现该初始化器，如果子类中没有实现就会报如下错误。当我们不想让继承类破坏初始化入口的结构的时候可以采用这种方式。

类的内存结构探索

swift 代码编译流程

iOS 开发的语言不管是 OC 还是 Swift 后端都是通过 LLVM 进行编译的，如下图所示，详细的介绍大家也可以参考下这篇文章 LLVM 的介绍及编译流程分析。

OC 通过 clang 编译器，编译成 IR，然后再生成可执行文件 .o (这里也就是我们的机器码)。

Swift 则是通过 Swift 编译器编译成 IR，然后在生成可执行文件。以下是 Swift 代码生成机器码的过程。

大家也可以根据以下命令生成不同阶段对应的文件：

// 分析输出AST
swiftc main.swift -dump-parse
// 分析并且检查类型输出AST 
swiftc main.swift -dump-ast

// 生成中间体语言(SIL)，未优化 
swiftc main.swift -emit-silgen

// 生成中间体语言(SIL)，优化后的 
swiftc main.swift -emit-sil

// 生成LLVM中间体语言 (.ll文件) 
swiftc main.swift -emit-ir

// 生成LLVM中间体语言 (.bc文件) 
swiftc main.swift -emit-bc

// 生成汇编
swiftc main.swift -emit-assembly

// 编译生成可执行.out文件 
swiftc -o main.o main.swift

swift 类的数据结构分析

下面我们通过把 swift 代码生成 SIL 代码来分析一下。

swift 代码：

class CXTeacher{
  var age: Int = 18
  var name: String = "chenxi"
}

var t = CXTeacher()

SIL 代码：

// CXTeacher 的声明
class CXTeacher {
// 初始化过的存储属性
  @_hasStorage @_hasInitialValue var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
// 带 objc 标识的函数
  @objc deinit
//默认初始化函数
  init()
}

sil @main : $@convention(c) (Int32, UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer<Optional<UnsafeMutablePointer<Int8>>>):
  alloc_global @$s4main1tAA9CXTeacherCvp          // id: %2
  %3 = global_addr @$s4main1tAA9CXTeacherCvp : $*CXTeacher // user: %7
  %4 = metatype $@thick CXTeacher.Type            // user: %6
  // function_ref CXTeacher.__allocating_init()
  %5 = function_ref @$s4main9CXTeacherCACycfC : $@convention(method) (@thick CXTeacher.Type) -> @owned CXTeacher // user: %6
  %6 = apply %5(%4) : $@convention(method) (@thick CXTeacher.Type) -> @owned CXTeacher // user: %7
  store %6 to %3 : $*CXTeacher                    // id: %7
  %8 = integer_literal $Builtin.Int32, 0          // user: %9
  %9 = struct $Int32 (%8 : $Builtin.Int32)        // user: %10
  return %9 : $Int32                              // id: %10
}

@main ：入口函数。
%x ：寄存器，但是是虚拟的。
alloc_global：声明一个全局变量，s4main1tAA9CXTeacherCvp 是混写过后的名称，可以通过 xcrun swift-demangle 混写名称 命令查看，查看之后可以看到就是我们定义的变量 t。
global_addr：拿到全局变量的地址赋值给 %3 寄存器。
metatype $@thick CXTeacher.Type：获取 CXTeacher.Type 的元类型并赋值给 %4 寄存器。
function_ref：拿到函数的指针地址并赋值给 %5 寄存器。
apply：使用函数指针%5 ，并且需要一个参数 %4，也就元类型，并赋值给 %6 寄存器。
store %6 to %3：把 %6 赋值给 %3，这里 %6 就是通过 __allocating_init 函数创建的对象。
%8 = integer_literal $Builtin.Int32, 0 ，%9 = struct $Int32 (%8 : $Builtin.Int32)：Int 类型在 swift 中是结构体类型，所以这两行就是构建一个 Int32 的整数类型。
return %9 : $Int32：相当于 main 函数中的 return 0。

以上是对 SIL 代码的注释，更具体的语法规则大家也可以参考官方文档：SIL语法文档地址。

因为这里我们要探究类的内存结构，在 apply 的时候使用了函数指针，并创建了 CXTeacher 对象，所以我们在生成的 SIL 文件中搜索 s4main9CXTeacherCACycfC。

其中 alloc_ref 我们不知道代表的是什么意思，所以可以在官方文档搜索。

通过文档解释我们可以看到 alloc_ref 其实就是到堆区开辟内存空间，默认引用计数为1，当 swift 类继承于 NSObject 的时候则会执行 OC 中的对象的创建方法。

下面我们打开汇编调试，追踪一下 CXTeacher 对象创建的时候汇编代码的执行。

通过汇编代码我们可以看到，对象创建的时候会执行 swift_allocObject 跟 init 函数。

下面我们需要借助源码来查看 swift_allocObject 函数的具体执行，大家可以到 Swift-git 下载任意版本的Swift源码。

// _swift_allocObject_ 函数需要三个参数，metadata ：元类型，requiredSize ：需要空间大小，requiredAlignmentMask ：掩码大小，其实 requiredAlignmentMask 是 7，因为结构体需要8字节对齐
static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
                                       size_t requiredSize,
                                       size_t requiredAlignmentMask) {
  assert(isAlignmentMask(requiredAlignmentMask));
  auto object = reinterpret_cast<HeapObject *>(
      swift_slowAlloc(requiredSize, requiredAlignmentMask));

  // NOTE: this relies on the C++17 guaranteed semantics of no null-pointer
  // check on the placement new allocator which we have observed on Windows,
  // Linux, and macOS.
  new (object) HeapObject(metadata);

  // If leak tracking is enabled, start tracking this object.
  SWIFT_LEAKS_START_TRACKING_OBJECT(object);

  SWIFT_RT_TRACK_INVOCATION(object, swift_allocObject);

  return object;
}

void *swift::swift_slowAlloc(size_t size, size_t alignMask) {
  void *p;
  // This check also forces "default" alignment to use AlignedAlloc.
  if (alignMask <= MALLOC_ALIGN_MASK) {
#if defined(__APPLE__) && SWIFT_STDLIB_HAS_DARWIN_LIBMALLOC
    p = malloc_zone_malloc(DEFAULT_ZONE(), size);
#else
// 最终空间的申请也是调用 malloc 函数
    p = malloc(size);
#endif
  } else {
    size_t alignment = (alignMask == ~(size_t(0)))
                           ? _swift_MinAllocationAlignment
                           : alignMask + 1;
    p = AlignedAlloc(size, alignment);
  }
  if (!p) swift::crash("Could not allocate memory.");
  return p;
}

struct HeapObject {
  /// This is always a valid pointer to a metadata object.
  HeapMetadata const *__ptrauth_objc_isa_pointer metadata;

  SWIFT_HEAPOBJECT_NON_OBJC_MEMBERS;
}

打开源码之后找到 HeapObject.cpp 文件，这个文件是跟对象初始化相关的，在此文件中搜索 swift_slowAlloc 可以找到以上源代码，通过对源码的分析，我们可以得出以下结论。

Swift 对象内存分配:

_allocating_init -----> swift_allocObject -----> _swift_allocObject -----> swift_slowAlloc -----> malloc
Swift 对象的内存结构 HeapObject (OC objc_object) ，有两个属性: 一个是 Metadata，一个是 RefCount ，默认占用 16 字节大小。

知道了 HeapObject 的数据结构，下面我们来探究一下 HeapMetadata 的数据结构。

template <typename Target> struct TargetHeapMetadata;
// 类似于别名的定义，TargetHeapMetadata 是一个泛型，接收一个 InProcess 参数
using HeapMetadata = TargetHeapMetadata<InProcess>;

// 这里可以看到 TargetHeapMetadata 继承于 TargetMetadata
struct TargetHeapMetadata : TargetMetadata<Runtime> {
  using HeaderType = TargetHeapMetadataHeader<Runtime>;
// 初始化的时候会判断如果是纯 swift 类，结果就 MetadataKind 类型，如果是继承于 NSObject 则是 isa
  TargetHeapMetadata() = default;
  constexpr TargetHeapMetadata(MetadataKind kind)
    : TargetMetadata<Runtime>(kind) {}
#if SWIFT_OBJC_INTEROP
  constexpr TargetHeapMetadata(TargetAnyClassMetadata<Runtime> *isa)
    : TargetMetadata<Runtime>(isa) {}
#endif
};

enum class MetadataKind : uint32_t {
#define METADATAKIND(name, value) name = value,
#define ABSTRACTMETADATAKIND(name, start, end)                                 \
  name##_Start = start, name##_End = end,
#include "MetadataKind.def"
  LastEnumerated = 0x7FF,
};

MetadataKind 是 uint32_t 类型，以下是 kind 类型的定义。

struct TargetMetadata {
  using StoredPointer = typename Runtime::StoredPointer;

  /// The basic header type.
  typedef TargetTypeMetadataHeader<Runtime> HeaderType;

  constexpr TargetMetadata()
    : Kind(static_cast<StoredPointer>(MetadataKind::Class)) {}
  constexpr TargetMetadata(MetadataKind Kind)
    : Kind(static_cast<StoredPointer>(Kind)) {}
}

因为 TargetHeapMetadata 继承于 TargetMetadata，所以我们继续搜索 TargetMetadata，到这里可以看到 TargetMetadata 好像就是基类了，但是到这里我们好像进入瓶颈了，因为到此依然不知道 swift 类的数据结构，所以这里我们就要来分析 TargetMetadata 这个类了。

  ConstTargetMetadataPointer<Runtime, TargetTypeContextDescriptor>
  getTypeContextDescriptor() const {
    switch (getKind()) {
    case MetadataKind::Class: {
      const auto cls = static_cast<const TargetClassMetadata<Runtime> *>(this);
      if (!cls->isTypeMetadata())
        return nullptr;
      if (cls->isArtificialSubclass())
        return nullptr;
      return cls->getDescription();
    }
    case MetadataKind::Struct:
    case MetadataKind::Enum:
    case MetadataKind::Optional:
      return static_cast<const TargetValueMetadata<Runtime> *>(this)
          ->Description;
    case MetadataKind::ForeignClass:
      return static_cast<const TargetForeignClassMetadata<Runtime> *>(this)
          ->Description;
    default:
      return nullptr;
    }
  }

通过对 TargetMetadata 类的分析我们找到了 getTypeContextDescriptor 函数，这里会通过 getKind 对 kind 类型进行判断，用来区分是 Class 类型还是 Struct 等其他类型。这里也可以得出结论 TargetMetadata 是所以类型原类的最终基类，这里可以看到当是 Class 类型的时候，会把 this 指针强转为 TargetClassMetadata 类型，所以我们搜索 TargetClassMetadata。

经过以上的源码分析，我们可以得出 swift 类的数据结构如下：

struct Metadata{ 
    var kind: Int
    var superClass: Any.Type
    var cacheData: (Int, Int)
    var data: Int
    var classFlags: Int32
    var instanceAddressPoint: UInt32
    var instanceSize: UInt32
    var instanceAlignmentMask: UInt16
    var reserved: UInt16
    var classSize: UInt32
    var classAddressPoint: UInt32
    var typeDescriptor: UnsafeMutableRawPointer
    var iVarDestroyer: UnsafeRawPointer
}

下面我们通过代码来证明一下我们的推论是否正确。

struct Metadata{ 
    var kind: Int
    var superClass: Any.Type
    var cacheData: (Int, Int)
    var data: Int
    var classFlags: Int32
    var instanceAddressPoint: UInt32
    var instanceSize: UInt32
    var instanceAlignmentMask: UInt16
    var reserved: UInt16
    var classSize: UInt32
    var classAddressPoint: UInt32
    var typeDescriptor: UnsafeMutableRawPointer
    var iVarDestroyer: UnsafeRawPointer
}

// 实例对象的结构体
struct HeapObject {
    // 原生的指针
    var metadate: UnsafeRawPointer
    var refcounted1: uint32
    var refcounted2: uint32
}

class CXTeacher {
  var age: Int = 18
  var name: String = "chenxi"
}

var t = CXTeacher()

// 获取实例对象的指针
let objcRawPtr = Unmanaged.passUnretained(t as AnyObject).toOpaque()
// 将 objcRawPtr 绑定成 HeapObject 类型
let objcPtr = objcRawPtr.bindMemory(to: HeapObject.self, capacity: 1)
// objcPtr.pointee 获取指针，swift 固定语法
print(objcPtr.pointee)

// 将 objcPtr.pointee.metadate 的指针绑定为 Metadata.self 类型，MemoryLayout 用来测量数据类型的大小
let metadata = objcPtr.pointee.metadate.bindMemory(to: Metadata.self, capacity: MemoryLayout<Metadata>.stride).pointee

print(metadata)

通过代码运行后的打印也证明了我们以上的推论是正确的。