Swift5.x入门11--属性，延迟属性，属性观察器，inout，单例模式

属性

• 在Swift中与实例相关的属性可以分为两大类；

• 第一类：存储属性

  • 类似于成员变量的概念；
  • 存储在实例对象的内存中；
  • 结构体与类可以定义存储属性；
  • 枚举是不可以定义存储属性的；

• 第二类：计算属性

  • 本质就是方法函数；
  • 不占用实例对象的内存；
  • 枚举，结构体，类都可以定义计算属性(方法)；

import Foundation

struct Circle {
    //存储属性
    var radius: Int
    //计算属性
    var diameter: Int{
        set {
            radius = newValue / 2
        }
        get {
            radius * 2
        }
    }
}

var c = Circle(radius: 10)
print(MemoryLayout.stride(ofValue: c))
c.radius = 20
c.diameter = 40

存储属性

• 在创建类或者结构体实例时，必须为所有的存储属性设置一个合适的初始值；

计算属性

• set方法传入的新值默认叫做newValue，也可以自定义名称；
• 只读计算属性，只有get，没有set；
• 定义计算属性，只能用var，不能用let，因为计算属性值的会随时发生变化的；

import Foundation
import UIKit

class Rectanle {
    //存储属性
    var width: Int = 100
    var height: Int = 50
    
    //可读可写的计算属性 有get set 方法
    var area: Int {
        set {
            width = newValue / height
        }
        get {
            return width * height
        }
    }
    
    //只读的计算属性 只有get方法 
    var color: UIColor{
        return UIColor.red
    }

//    var color: UIColor{
//        get {
//            return UIColor.red
//        }
//    }
}

• 只读的计算属性 只有get方法，其中get{}可以省略，实现体直接写在{ }里面即可；

计算属性在get方法中返回自己的值

import UIKit
import MJRefresh

class SFRefreshFooter: MJRefreshAutoStateFooter {
    //存储属性
    var _noDataTextString: String = ""
    var _customColor: UIColor = UIColor.gray
    //计算属性
    var noDataTextString: String {
        get {
            return _noDataTextString
        }
        set {
            _noDataTextString = newValue
            isAutomaticallyHidden = true
            setTitle(newValue, for: .noMoreData)
        }
    }
}

• 可定义一个同名带下划线的存储属性，当计算属性调用set方法时，内部给同名带下划线的存储属性赋值，然后在计算属性的get方法中直接返回同名带下划线的存储属性；

枚举原始值的原理

enum Season : Int {
    case spring = 1,summer,autum,winter
    
    var rawValue: Int {
        switch self {
        case .spring:
            return 11
        case .summer:
            return 22
        case .autum:
            return 33
        case .winter:
            return 44
        }
    }
}

var season = Season.spring
print(season.rawValue) //11

• 若没有定义计算属性rawValue，那么系统返回的season.rawValue = 1
• 现新定义了一个计算属性rawValue，season.rawValue = 11；说明枚举原始值的本质就是只读的计算属性，不会占用枚举实例的内存空间，占用枚举实例内存空间的事枚举实例的关联值与区分枚举的case
• rawValue，只有getter方法，没有setter方法，只读的；

延迟存储属性

• 使用lazy可以定义一个延迟存储属性，在第一次用到属性的时候才会进行初始化；

class Car {
    init() {
        print("car init!")
    }
    func run() -> Void {
        print("car is running!")
    }
}

class Person {
    var car = Car()
    init() {
        print("person init!")
    }
    func goOut() -> Void {
        car.run()
    }
}

let person = Person()
print("---------")
person.goOut()

• 调试结果如下：

Snip20210801_83.png

• 若将Person类中的存储属性car，前面加关键字lazy，如下：

class Person {
    lazy var car = Car()
    init() {
        print("person init!")
    }
    func goOut() -> Void {
        car.run()
    }
}

• 执行结果如下：

Snip20210801_84.png

• lazy属性必须是var修饰，不能是let修饰；
• let必须在实例的初始化方法完成之前就有值；
• 如果有多条线程同时第一次访问lazy属性时，属性可能会被初始化多次，也就是说lazy属性不是线程安全的；

延迟存储属性的注意点

• 当结构体包含一个延迟存储属性时，只有var才能访问延迟存储属性，因为延迟存储属性初始化时，会改变结构体的内存；
• 如下所示：

Snip20210801_86.png

• let point = Point()初始化结构体实例对象，因为let修饰，那么结构体实例对象的内存就不能发生变化，现在调用point.z，那么会初始化结构体实例对象的z成员，那么结构体实例对象就发生了变化，前后矛盾，就会报错，所以只能用var修饰结构体实例对象；

属性观察器

• 可以为非lazy的var存储属性设置属性观察器；

import Foundation

struct Circle {
    //存储属性
    var radius: Int{
        willSet{
            print("willSet",newValue)
        }
        didSet{
            print("willSet",oldValue,radius)
        }
    }
    //计算属性
    var diameter: Int{
        set {
            radius = newValue / 2
        }
        get {
            radius * 2
        }
    }
    init() {
        self.radius = 1
        print("Circle init!")
    }  
}

var c = Circle()
c.radius = 20

• 为存储属性radius设置了两个属性观察器，分别为willSet与didSet
• willSet：当存储属性radius即将设置时会调用；
• didSet：当存储属性radius即将设置完成时会调用；
• 调试结果如下：

Snip20210801_87.png

• willSet会传递新值，默认叫做newValue；
• didSet会传递旧值，默认叫做oldValue；
• 在初始化器中设置存储属性时不会触发属性观察器willSet与didSet；
• 在存储属性定义时设置初始值也不会触发属性观察器willSet与didSet；

全局变量与局部变量

• 属性观察器，计算属性的功能，同样可以应用在全局变量与局部变量上；

import Foundation

var num: Int {
    get{
        return 10
    }
    set{
        print("setNum",newValue)
    }
}

num = 11   //setNum 11
print(num) //10

• num是一个全局变量，可以使用计算属性的功能；

func test() -> Void {
    var age = 10 {
        willSet {
            print("willSet",newValue)
        }
        didSet {
            print("didSet",oldValue,age)
        }
    }
    age = 11
}
test()
//willSet 11
//didSet 10 11

• age是一个局部变量，可以使用属性观察器；

inout的研究

import Foundation

var age = 10

func test(_ num: inout Int) -> Void {
    print("test")
    num = 20
}

test(&age)
print(age) //20

• 当断点停在test(&age)所在代码行，汇编代码如下：

Snip20210801_90.png

• leaq 0x423a(%rip), %rdi：是将(rip+ 0x423a)这个全局变量的地址值，也就是age的地址值写入rdi寄存器，最终调用test函数，传入的参数就是age的地址值，即地址的传递，那么可以早在test函数内部修改外界变量age的值了；
• 再看下面一段代码：

import Foundation

struct Shape {
    //宽度
    var width: Int
    //边数
    var side: Int{
        willSet {
            print("willSet",newValue)
        }
        didSet {
            print("didSet",oldValue,side)
        }
    }
    //周长
    var girth: Int{
        set {
            width = newValue / side
            print("setGirth",newValue)
        }
        get {
            print("getGirth")
            return width * side
        }
    }
    
    func show() -> Void {
        print("width = \(width),side = \(side),girth = \(girth)")
    }
}

func test(_ num: inout Int) -> Void {
    print("test")
    num = 20
}

var shape = Shape(width: 10, side: 4)
test(&shape.width) //width = 20,side = 4,girth = 80
shape.show()

先来探索第一个存储属性width；

• 当断点停在test(&shape.width)所在代码行，汇编代码如下：

Snip20210801_91.png

• leaq 0x513e(%rip), %rdi：将(rip+ 0x513e)的内存地址，也就是结构体实例变量shape的内存地址写入rdi寄存器中；
• callq 0x1000039b0：就是调用test函数，传入的参数就是rdi寄存器中内容，也就是结构体实例变量shape的内存地址，由于shape是值类型，成员width的内存地址与shape的内存地址是相同的，占用shape的首8个字节；
• 由于传入的是width引用地址，所以width的值被改成了20；

再来探索第三个计算属性girth；

• 调用代码做如下修改，传入的是计算属性girth；

var shape = Shape(width: 10, side: 4)
test(&shape.girth)
shape.show() //width = 5,side = 4,girth = 20

• 当断点停在test(&shape.girth)，所在行时，汇编代码如下：

Snip20210801_92.png

• 前后调用了三个方法，分别为girth的getter方法，test方法，girth的setter方法，汇编分析如下：
• movq %rax, -0x28(%rbp)：rax中存储的就是girth的值；
• leaq -0x28(%rbp), %rdi：-0x28(%rbp)就是临时内存；
• 接着进入test函数实现，汇编如下：

Snip20210801_94.png

• movq $0x14, (%rdi)：这里就是修改了临时内存的值为20；
• 再接着执行setter方法，回到main函数；
• movq -0x28(%rbp), %rdi，将临时内存中的值20，写入rdi参数寄存器;
• leaq 0x5088(%rip), %r13，将结构体实例shape，写入r13参数寄存器;
• 最后将rdi与r13传给setter方法；
• 其实现原理如下所示：

Snip20210801_93.png

最后探索第二个加油属性观察器的存储属性side

var shape = Shape(width: 10, side: 4)
test(&shape.side)
shape.show() //width = 10,side = 20,girth = 200

• • 当断点停在test(& shape.side)，所在行时，汇编代码如下：
    
    Snip20210801_95.png
• movq 0x50b4(%rip), %rax： 将shape+8也就是side的值写入rax寄存器；
• movq %rax, -0x28(%rbp)：将side的值写入(rbp-0x28)内存中；
• leaq -0x28(%rbp), %rdi：将(rbp-0x28)内存写入rdi，然后传给test函数，test函数内部，修改(rbp-0x28)内存中值为20；
• movq -0x28(%rbp), %rdi：将(rbp-0x28)内存中值为20，写入rdi寄存器中；
• 最后将rdi传递给setter方法；

总结：

• 如果实参有物理内存地址，且没有设置属性观察器，会直接将实参的内存地址传入函数(实参进行引用传递)
• 如果实参是计算属性，或者 设置了属性观察器，则采取了Copy In Copy Out的做法，即调用该函数时，
  • 首先赋值实参的值，产生副本(getter方法)；
  • 然后将副本的内存地址传入函数(副本进行引用传递)，在函数内部可以修改副本的值；
  • 最后函数返回后，将副本的值覆盖实参的值(setter方法)
• inout的本质就是地址传递，引用传递；

类型属性

• 严格来说属性可以分为：
  • 实例属性：只能通过实例去访问；
    • 存储实例属性：存储在实例的内存中，每个实例都有一份；
    • 计算实例属性：不会存储在实例的内存中，本质是方法；
  • 类型属性：只能通过类去访问；
    • 存储类型属性：整个程序运行过程中，就只有一份内存，类似于全局变量；
    • 计算类型属性：
• 可以通过static或者class定义类型属性，class修饰可被子类重写，static修饰不可被子类重写；

struct Shape {
    var width: Int = 0
    //存储类型属性
    static var count: Int = 0
}

var s = Shape()
Shape.count = 10
print(Shape.count)

struct Car {
    static var count: Int = 0
    init() {
        Car.count += 1
    }
}

let car1 = Car()
let car2 = Car()
let car3 = Car()
print(Car.count) //3

• 因为count是类型属性，只占一份内存，三个初始化器中，操作的都是同一块内存，所有数值递增；
• 存储类型属性，必须在定义的时候就要初始化值，否则会报错；
• 存储类型属性，默认是lazy，会在第一次使用的时候才初始化，就算同时被多个线程访问，也只会初始化一次，是线程安全的；
• 存储类型属性可以是let修饰；
• 枚举类型也可以定义类型属性；

enum Season {
    case spring,summer
    static var day: Int = 0
}

单例模式

class FileManager {
    //只有一份内存 默认lazy
    public static let shared = FileManager()
    //外界不允许初始化
    private init(){ }
    
    func open() -> Void {
        
    }
}

//单例调用
FileManager.shared.open()

汇编分析类型属性

import Foundation

var num1: Int = 10
var num2: Int = 20
var num3: Int = 30

• 定义三个全局变量，汇编代码如下：

Snip20210801_96.png

• num1的内存地址：(0x100003f91+0x406f)=0x100008000；
• num2的内存地址：(0x100003f9c+0x406c)=0x100008008；
• num3的内存地址：(0x100003fa7+0x4069)=0x100008010；
• 可以看出三个全局变量的内存地址是连续的，都占8个字节；
• 现将上述代码作以下修改：

var num1: Int = 10

class Car {
    static var count: Int = 1
}
Car.count = 15

var num3: Int = 30

• 汇编代码如下：

Snip20210801_99.png

• num1的内存地址：(0x100003bb3+0x45a5)=0x100008158；
• Car.count的内存地址： 0x100008160；
• num3的内存地址：(0x100003bfa+0x456e)= 0x100008168；
• 看到这三个全局变量的内存地址是连续的；
• 说明类的类型属性是全局变量在全局区分配内存，其与num1，num3最大的区别在于count有权限控制，count是必须通过类Car来进行访问的全局变量；
• static var count: Int = 1：类型属性count在定义的时候，进行了初始化，对应的汇编代码为callq 0x100003c40 ; Swift12_属性.Car.count.unsafeMutableAddressor : Swift.Int at main.swift
• 进入Car.count.unsafeMutableAddressor函数，汇编实现如下：

Snip20210801_100.png

• 内部会调用swift_once，swift_once的底层调用的GCD的dispatch_once，保证代码只执行一次，dispatch_once中传入的block闭包函数如上图所示：
• leaq -0x45(%rip), %rax，(rip-0x45)就是闭包函数的地址；
• movq %rax, %rsi：将闭包函数的地址存入rsi，再传递给swift_once；
• 当汇编断点断在callq 0x100003e60时，读取rsi中的值为：0x0000000100003c20
• 在源代码static var count: Int = 1打下断点，过掉当前的汇编断点，会进入闭包函数也就是static var count: Int = 1

Snip20210801_101.png

• 所以swift_once中保证只执行第一次初始化的代码就是static var count: Int = 1
• static var count: Int = 1类型属性默认是lazy的，所以触发点在于Car.count = 15，然后再执行swift_once，执行第一次初始化为1，最后再改成15；
• 这也就解释了static var count: Int = 1 为什么是线程安全的；