值类型

我们通过一段代码来了解下什么叫做值类型

func test() {
    var age = 18

    var age2 = age
    
    age = 20
    
    age2 = 30

    print("age:\(age)--age2:\(age2)")
}

test()

打印结果为age:20--age2:30，再通过观察地址来了解
值类型的特点：
- 1，地址中存储的是值
- 2，值类型的传递，传递的是值，类似于深拷贝

结构体

结构体的初始化

struct XQTeacher {
    var age : Int
    var name : String
}
var t = XQTeacher(age: 18, name: "xq")

不同于class，结构体可以不用给初始值且不用声明构造方法
查看sil文件，看到默认添加了init构造方法，这也是它能直接调用的原因

struct XQTeacher {
  @_hasStorage var age: Int { get set }
  @_hasStorage var name: String { get set }
  init(age: Int, name: String)
}

通过打印来观察结构体为什么是值类型，可以看到直接po并没有输出地址，通过获取地址查看内存可以直接看到两个属性的值
再通过赋值给t1，再修改t1的值看看t有没有变化
观察sil文件验证，可以看到在main函数里面并没有分配内存的方法，而是直接调用了function_ref XQTeacher.init()
XQTeacher.init()的实现如下，通过在栈区创建了一个XQTeacher 类型的结构体，初始化操作之后返回。

// XQTeacher.init()
sil hidden @$s4main9XQTeacherVACycfC : $@convention(method) (@thin XQTeacher.Type) -> @owned XQTeacher {
// %0 "$metatype"
bb0(%0 : $@thin XQTeacher.Type):
  %1 = alloc_stack $XQTeacher, let, name "self"   // users: %12, %4, %16, %17
  %2 = integer_literal $Builtin.Int64, 18         // user: %3
  %3 = struct $Int (%2 : $Builtin.Int64)          // users: %5, %14
  %4 = struct_element_addr %1 : $*XQTeacher, #XQTeacher.age // user: %5
  store %3 to %4 : $*Int                          // id: %5
  %6 = string_literal utf8 "xq"                   // user: %11
  %7 = integer_literal $Builtin.Word, 2           // user: %11
  %8 = integer_literal $Builtin.Int1, -1          // user: %11
  %9 = metatype $@thin String.Type                // user: %11
  // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
  %10 = function_ref @$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %11
  %11 = apply %10(%6, %7, %8, %9) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // users: %14, %13
  %12 = struct_element_addr %1 : $*XQTeacher, #XQTeacher.name // user: %13
  store %11 to %12 : $*String                     // id: %13
  %14 = struct $XQTeacher (%3 : $Int, %11 : $String) // users: %18, %15
  retain_value %14 : $XQTeacher                   // id: %15
  destroy_addr %1 : $*XQTeacher                   // id: %16
  dealloc_stack %1 : $*XQTeacher                  // id: %17
  return %14 : $XQTeacher                         // id: %18
} // end sil function '$s4main9XQTeacherVACycfC'

引用类型

类

类的初始化，如果属性没有初始值且不是可选类型，编译器会报错，也不会像结构体一样自动生成初始化方法。

class XQTeacher {
    var age : Int = 18
    var name : String = "xq"
}
var t = XQTeacher()

引用类型的特点
- 1，地址中存储的是内存中所在地址
- 2，内存中所在地址中存储的才是值
查看sil文件，可以看到是调用XQTeacher.__allocating_init()方法分配内存并初始化
再通过打印来看类与结构体的区别，类的实例对象可以直接打印出内存地址，也可以通过指针查看内存地址，再通过地址去访问对象的值。
赋值给t1，修改t1的值看对t是不是有影响，可以看到t1和t的地址是相同的，修改其中任何一个都会有影响。

结构体包含类对象属性

在结构体中增加一个类对象属性，赋值给t1，修改实例对象的属性值，同样会影响t
虽然结构体是值类型，传递的是值，但是对于teacher，它还是引用类型传递的是地址
所以我们尽量在值类型中包含引用类型
查看sil文件，每次操作XQTeacher1都是有引用计数管理操作的

方法

结构体的方法

通过上文知道结构体是一个值类型，那么它的方法会存在什么地方呢，我们通过一个例子来看下结构体方法是怎么调用的
运行之后，进入断点，可以看到它是直接callq一个地址，说明是一个静态方法，静态方法是在编译链接之后就确定了地址的，调用的时候直接调用这个地址。
我们通过MachOView来查看，可以看到编译之后的可执行文件也是调用的这个地址。
我们在符号表Symbol Table中找到push函数
我们也可以在终端中输入nm path可执行文件路径来打印所有的符号
可以看到它的名字是经过混淆的，我们可以通过命令xcrun swift-demangle s13SwiftTypeDemo7XQStackV4pushyySiF还原
我们可以看到swift的符号重整规则比较复杂，那是因为swift可以通过不同的参数来重载同一个函数，需要依赖这种相对复杂的符号重整规则来保证符号的唯一性，补充：c++也有类似比较复杂的命名重整规则，c/oc相对比较简单

在release环境下我们的静态方法是不会保存在符号表中的，符号表中保存的是我们找不到确定地址的符号也就是我们懒加载的符号，懒加载的符号的地址会在第一次调用的时候才会确定，通过dylb绑定确定调用地址我们在machOView中看到的地址是没有使用ALSR随机地址偏移技术的，而在我们手机或者模拟器运行的时候是要加上这个偏移地址才是真实调用地址

类中的方法

方法表

类中的方法是通过方法表(V-table)来进行调度的
我们通过一个例子来看一下在sil文件中方法表

class XQTeacher {
    func teach() { print("teach") }
    func teach1() { print("teach1") }
    func teach2() { print("teach2") }
    func teach3() { print("teach3") }
}

sil文件

sil_vtable XQTeacher {
  #XQTeacher.teach: (XQTeacher) -> () -> () : @$s4main9XQTeacherC5teachyyF	// XQTeacher.teach()
  #XQTeacher.teach1: (XQTeacher) -> () -> () : @$s4main9XQTeacherC6teach1yyF	// XQTeacher.teach1()
  #XQTeacher.teach2: (XQTeacher) -> () -> () : @$s4main9XQTeacherC6teach2yyF	// XQTeacher.teach2()
  #XQTeacher.teach3: (XQTeacher) -> () -> () : @$s4main9XQTeacherC6teach3yyF	// XQTeacher.teach3()
  #XQTeacher.init!allocator: (XQTeacher.Type) -> () -> XQTeacher : @$s4main9XQTeacherCACycfC	// XQTeacher.__allocating_init()
  #XQTeacher.deinit!deallocator: @$s4main9XQTeacherCfD	// XQTeacher.__deallocating_deinit
}

首先是sil_vtable的关键字，然后是XQTeacher表明当前是XQTeacherclass的函数表其次就是当前方法的声明对应着方法的名称这张表的本质其实就类似我们理解的数组，声明在class内部的方法在不加任何关键字修饰的过程中，连续存放在我们当前的地址空间中。

观察汇编代码

通过断点查看汇编调用
运行进入断点，可以看到是通过实例变量的首地址偏移找到对应方法地址，而且每个方法的都是相差8个字节。

查看方法表源码

在swift源码中搜索initClassVTable方法，打下断点，输入调试代码，进入断点
可以看到是通过一个for循环将方法加入到方法表中。

类扩展中增加方法

如果我们再类扩展里面实现一个teach4方法，看看它的调用会是什么情况
运行进入断点，可以看到它是直接静态调用
为什么在扩展中的方法不会加入到方法表中呢？
我们创建一个XQStudent继承自XQTeacher

class XQTeacher {
    func teach() { print("teach") }
    func teach1() { print("teach1") }
    func teach2() { print("teach2") }
    func teach3() { print("teach3") }
}

class XQStudent: XQTeacher {
    func study() {
        print(print("study"))
    }
}

观察sil文件，可以看到子类的方法表直接继承了全部父类的方法，然后再后面添加自己的方法，而我们在扩展类的时候并没有index标识对应的方法如果再加入到方法表会造成混乱，而且在oc中我们知道方法是存在一个数组中的，对数组的操作比较麻烦需要使用memmove和memcpy方法平移拷贝等。

常用的关键字

关键字mutaing

我们想通过结构体实现一个类似栈的功能，有一个push方法。
修改代码成打印item，再查看对应sil文件，可以看到push传递两个参数，除了item还有一个默认的self，使用let修饰的常量，所以对items的修改是不允许的
我们可以尝试将代码修改成下面这样，再运行，打印为空，原因是因为虽然我们将它转成了变量但是结构体是值传递，修改方法里面的结构体不会对外面有影响
我们可以使用mutating 关键字修饰方法，再次运行就可以实现我们想要的效果了

struct XQStack {
    var items : [Int] = []
    mutating func push(_ item : Int) {
        items.append(item)
    }
}

var s = XQStack()
s.push(1)
print(s.items)

查看sil文件，可以看到mutating 修饰的方法会将默认参数用inout修饰，在方法里self就是var修饰的变量。

// XQStack.push(_:)
sil hidden @$s4main7XQStackV4pushyySiF : $@convention(method) (Int, @inout XQStack) -> () {
// %0 "item"                                      // users: %5, %2
// %1 "self"                                      // users: %6, %3
bb0(%0 : $Int, %1 : $*XQStack):
  debug_value %0 : $Int, let, name "item", argno 1 // id: %2
  debug_value_addr %1 : $*XQStack, var, name "self", argno 2 // id: %3
  %4 = alloc_stack $Int                           // users: %5, %11, %9
  store %0 to %4 : $*Int                          // id: %5
  %6 = begin_access [modify] [static] %1 : $*XQStack // users: %10, %7
  %7 = struct_element_addr %6 : $*XQStack, #XQStack.items // user: %9
  // function_ref Array.append(_:)
  %8 = function_ref @$sSa6appendyyxnF : $@convention(method) <τ_0_0> (@in τ_0_0, @inout Array<τ_0_0>) -> () // user: %9
  %9 = apply %8<Int>(%4, %7) : $@convention(method) <τ_0_0> (@in τ_0_0, @inout Array<τ_0_0>) -> ()
  end_access %6 : $*XQStack                       // id: %10
  dealloc_stack %4 : $*Int                        // id: %11
  %12 = tuple ()                                  // user: %13
  return %12 : $()                                // id: %13
} // end sil function '$s4main7XQStackV4pushyySiF'

inout

默认情况下函数的参数是不可变的，如果需要修改，可以使用关键字inout修饰
加入关键字之后就可以编译通过了，但是在使用函数时
对比两个方法，一个参数使用了inout修饰，一个没有使用，查看sil文件，可以发现一个是去地址，一个是直接使用值
总结：
- 1，值类型本身创建之后是不允许更改的，如果需要修改，需要使用mutating 修饰函数，而类不需要
- 2，mutating的本质就是给隐式参数self用inout修饰，传递过去的参数就是取地址了，而不是值传递
- 3，inout修饰的参数是使用地址的，不是值传递，是引用
- 4，mutating修饰的是函数，一般只用于值类型；inout修饰的是参数

final

使用final修饰函数teach，可以让函数变成静态调用
运行后进入断点，可以发现teach是静态调用

@objc

@objc将头文件暴露给oc调用，并没有修改函数的调用方式
进入断点后，可以看到还是使用方法表调度
新建一个oc项目，创建一个Test.swift文件
导入头文件#import "OCTestDemo-Swift.h"，进入头文件并没有看到有相关XQTeacher的声明，原因是XQTeacher是一个纯Swift类，还得将XQTeacher继承自NSObject，编译之后就可以在头文件中看到下面代码，也就可以使用XQTeacher类了
通过sil文件来看看@objc做了什么，可以看到生成了一个XQTeacher.teach()函数和一个@objc XQTeacher.teach()函数
@objc XQTeacher.teach()函数里面又调用了XQTeacher.teach()