Swift底层进阶--003：值类型 & 引⽤类型

值类型

结构体的初始化

struct LGTeacher{
    var age: Int
    var name: String = "Zang"
}

var t = LGTeacher(age:18)

• 结构体中的属性，即使没有默认值，编译器也不会报错
• 当开发者没有手动实现init方法时，编译器会自动生成对应初始化方法

通过SIL进行验证：

struct LGTeacher {
  @_hasStorage var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
//编译器自动生成的初始化方法
  init(age: Int, name: String = "Zang")
}

上述代码中的init(age: Int, name: String = "Zang")是编译器自动生成的初始化方法

以下代码，由我们手动声明init(age:Int)方法，编译器会怎样？

struct LGTeacher{
    var age: Int
    var name: String = "Zang"
    
    init(age:Int) {
        self.age=age
    }
}

var t = LGTeacher(age:18)

通过SIL进行验证：

struct LGTeacher {
  @_hasStorage var age: Int { get set }
  @_hasStorage @_hasInitialValue var name: String { get set }
//只有一个手动声明的初始化方法
  init(age: Int)
}

可以看到，之前编译器自动生成的初始化方法都不见了，只有一个手动声明的init(age:Int)方法

结构体是值类型

struct LGTeacher{
    var age1: Int = 18
    var age2: Int = 20
}

var t = LGTeacher()

使用po、x/8g，查看t的输出：

t的输出

• po t，可以看到直接输出了t的值，没有地址。说明在内存中，结构体直接存储值
• po withUnsafePointer(to: &t){print($0)}，输出t的指针地址
• x/8g 0x0000000100008908，通过指针地址直接输出值
• 所以说结构体是值类型，结构体的地址就是第一个成员的内存地址

通过SIL进行验证：

// main
sil @main : $@convention(c) (Int32, UnsafeMutablePointer>>) -> Int32 {
bb0(%0 : $Int32, %1 : $UnsafeMutablePointer>>):
  alloc_global @main.t : main.LGTeacher          // id: %2
  %3 = global_addr @main.t : main.LGTeacher : $*LGTeacher // user: %7
  %4 = metatype $@thin LGTeacher.Type             // user: %6
  // function_ref LGTeacher.init()
  %5 = function_ref @main.LGTeacher.init() -> main.LGTeacher : $@convention(method) (@thin LGTeacher.Type) -> LGTeacher // user: %6
  %6 = apply %5(%4) : $@convention(method) (@thin LGTeacher.Type) -> LGTeacher // user: %7
  store %6 to %3 : $*LGTeacher                    // id: %7
  %8 = integer_literal $Builtin.Int32, 0          // user: %9
  %9 = struct $Int32 (%8 : $Builtin.Int32)        // user: %10
  return %9 : $Int32                              // id: %10
} // end sil function 'main'

上述代码t的初始化，只有init方法，没有malloc，所以结构体是分配在栈区，整体流程没有任何关于堆区的分配

值类型的传递

t1是LGTeacher的实例对象，将t1赋值给t2，再修改t1.age1，那t2.age1是否会一起改变？

struct LGTeacher{
    var age1: Int = 18
    var age2: Int = 20
}

var t1 = LGTeacher()
var t2=t1

t1.age1=30;

使用po、x/8g，查看t2.age1是否发生变化：

t2.age1

很明显t2.age1还是18，没有发生任何改变。

• t1和t2之间是值传递，将t1的值拷贝到t2中，相当于拷贝副本，也就是深拷贝。
• t1和t2是不同的内存空间，两个空间不共享状态。

引用类型

类的初始化

class LGTeacher{
    var age1: Int = 18
    var age2: Int = 20
}

var t1 = LGTeacher()

• 类的属性如果不是可选项，也没有初始默认值，编译报错：“Class LGTeacher has no initializers”
• 类的init方法必须由开发者自己实现

类是引用类型

使用po、x/8g，查看t的输出：

t的输出

• po t，直接输出的是t的地址
• po withUnsafePointer(to: &t){print($0)}，输出t的指针地址，是一个全局区地址
• x/8g 0x0000000100008a88，查看全局区地址，里面存储了对象的堆地址
• x/8g 0x00000001006526d0，通过堆地址输出值
• 所以说类是引用类型，地址内存储对象堆地址，堆地址内存储值

引用类型的传递

class LGTeacher{

    var age1: Int = 18
    var age2: Int = 20
}

var t1 = LGTeacher()
var t2=t1

t1.age1=30;

使用po、x/8g，查看t2.age1是否发生变化：

t2.age1

很明显t2.age1变成了30，因t1.age1的修改而修改。

• t1和t2之间是地址传递，t1和t2的地址内存储了相同的堆地址，一方修改都会修改，也就是浅拷贝。
• t1和t2是相同内存空间，两个空间共享状态。

结构体中包含类对象（值类型包含引用类型）

struct LGTeacher{
    var age1: Int = 18
    var age2: Int = 20
    var teacher: LGTeacher1 = LGTeacher1()
}

class LGTeacher1{
    var age1: Int = 18
    var age2: Int = 20
}

var t1 = LGTeacher()
var t2=t1

t1.teacher.age1=30;

使用po、x/8g，查看t2.teacher.age1是否发生变化：

t2.teacher.age1

很明显t2.teacher.age1跟着一起发生了改变。

• t1和t2虽然是结构体，但teacher是引用类型，所以传递的依然是地址
• 使用CFGetRetainCount(t1.teacher)可以看到t1.teacher引用计数为3
  LGTeacher.teacher.getter内执行strong_retain，引用计数+1
  LGTeacher.teacher.setter内执行strong_retain，引用计数+1
  CFGetRetainCount(t1.teacher)方法的调用，引用计数+1
• 在开发中，应避免值类型包含引用类型

mutating

值类型本身创建之后是不允许修改的，如果要修改，需要使⽤mutating关键字

编译报错

定义LGStack结构体，通过push方法向items里添加item，这时候必须在func前面添加mutating关键字，否则编译报错

先去掉items.append(item)，改为print(item)，保证编译通过

struct LGStack{
    var items = [Int]()
    
    func push(_ item : Int) {
        print(item)
    }
}

将上述代码生成SIL文件：

不使用mutating关键字

很明显，push方法除了item，还有一个默认self参数，而self被let修饰，故此不能修改

还原items.append(item)代码，在func之前增加mutating关键字

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

var t=LGStack()
t.push(1)

将上述代码生成SIL文件：

使用mutating关键字

代码发生了变化

• 传递的self被添加了inout输入输出参数
• self的修饰变成了var
• debug_value变成了debug_value_addr，值传递变为地址传递
• mutating用于修饰方法，不能修饰参数。本质就是为self增加inout关键字
• mutating只用于值类型，引用类型没有这种困惑

inout

在函数声明中，默认参数是不可变的。如果需要修改，必须在参数上增加inout关键字

编译报错

声明swap函数，有a、b两个参数，在函数内部交互两个参数的值，这时候必须在参数上增加inout关键字，否则编译报错

正确的写法

func swap(a: inout Int, b: inout Int) {
    let tmp=a;
    a=b;
    b=tmp;
}

var a = 10
var b = 20
swap(&a,&b)

print("a：\(a)")
print("b：\(b)")

//输出以下内容：
//a：20
//b：10

• inout关键字，将参数从取值变为取地址
• 调用函数传参时，必须传递地址。参数前加&符，例如：swap(&a,&b)
• inout关键字是输入输出参数，仅用于修饰参数

总结：

• 引⽤类型：类似在线表格，当多人共享编辑⼀个在线表格时，其实就是⼀个引⽤类型
• 值类型：类似本地excel，当我通过QQ传给你excel时，就相当于一个值类型，你修改的内容我并不知道