值类型

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

func test() {
    var age = 18

    var age2 = age
    
    age = 20
    
    age2 = 30

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

test()

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

结构体

• 结构体的初始化

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

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

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

• 通过打印来观察结构体为什么是值类型，可以看到直接po并没有输出地址，通过获取地址查看内存可以直接看到两个属性的值

  
  image.png

• 再通过赋值给t1，再修改t1的值看看t有没有变化

  
  image.png

• 观察sil文件验证，可以看到在main函数里面并没有分配内存的方法，而是直接调用了function_ref XQTeacher.init()
  

  image.png

• 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()方法分配内存并初始化
  image.png

• 再通过打印来看类与结构体的区别，类的实例对象可以直接打印出内存地址，也可以通过指针查看内存地址，再通过地址去访问对象的值。

  
  image.png

• 赋值给t1，修改t1的值看对t是不是有影响，可以看到t1和t的地址是相同的，修改其中任何一个都会有影响。

  
  image.png

结构体包含类对象属性

• 在结构体中增加一个类对象属性，赋值给t1，修改实例对象的属性值，同样会影响t

  
  image.png
• 虽然结构体是值类型，传递的是值，但是对于teacher，它还是引用类型传递的是地址
• 所以我们尽量在值类型中包含引用类型
• 查看sil文件，每次操作XQTeacher1都是有引用计数管理操作的
  image.png

关键字mutaing

• 我们想通过结构体实现一个类似栈的功能，有一个push方法。

  
  image.png

• 修改代码成打印item，再查看对应sil文件，可以看到push传递两个参数，除了item还有一个默认的self，使用let修饰的常量，所以对items的修改是不允许的

  
  image.png

• 我们可以尝试将代码修改成下面这样，再运行，打印为空，原因是因为虽然我们将它转成了变量但是结构体是值传递，修改方法里面的结构体不会对外面有影响

  
  

• 我们可以使用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修饰
  

  image.png

• 加入关键字之后就可以编译通过了

  
  image.png

• 对比两个方法，一个参数使用了inout修饰，一个没有使用，查看sil文件，可以发现一个是去地址，一个是直接使用值
  

  image.png

• 总结：

  • 1，结构体的函数中需要修改自身的属性，需要使用mutating修饰函数，而类不需要
  • 2，mutating的本质就是给隐式参数self用inout修饰
  • 3，inout修饰的参数是使用地址的，不是值传递，是引用
  • 4，mutating修饰的是函数，inout修饰的是参数