类与结构体探索1-定义、区别、初始化器

类与结构体的定义

struct/class LGTeacher{
    var age: Int
    var name: String
    
    init(age: Int, name: String)
    { 
        self.age = age
        self.name = name
    }
    
    deinit{
    }
    
}

类与结构体定义，除了使用的关键字不同，其他看似相同，但有本质区别。

结构体和类的主要相同点有:
定义存储值的属性
定义方法
定义下标以使用下标语法提供对其值的访问
定义初始化器
使用 extension 来拓展功能
遵循协议来提供某种功能
主要的不同点有:
类有继承的特性，而结构体没有
类型转换使您能够在运行时检查和解释类实例的类型
类有析构函数用来释放其分配的资源
引用计数允许对一个类实例有多个引用
类是引用类型，结构体是值类型
对于类与结构体我们需要区分的第一件事就是:
类是引用类型。也就意味着一个类类型的变量并不直接存储具体的实例对象，是对当前存储具体实例内存地址的引用。

引用类型与值类型

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

引用类型.png

值类型，一个值类型的变量存储的就是具体的实例，换句话说，就是具体的值

值类型.png

回顾内存区域

内存区域.png

栈区(stack): 局部变量和函数运行过程中的上下文
堆区(Heap): 存储所有对象
Global: 存储全局变量;
常量：TEXT.cstring、TEXT.const
代码区： Mach-O 文件中Text段中的__text

结合Mach-O类分析

Segment & Section: Mach-O 文件有多个段( Segment )，每个段有不同的功能。然后每个段又分为很多小的 Section
TEXT.text : 机器码
TEXT.cstring : 硬编码的字符串
TEXT.const: 初始化过的常量
DATA.data: 初始化过的可变的(静态/全局)数据 DATA.const: 没有初始化过的常量
DATA.bss: 没有初始化的(静态/全局)变量
DATA.common: 没有初始化过的符号声明

对象.png

结构体变量.png

验证结构体比类快

1.测试使用结构体、类创建各自使用的时间

import UIKit

let ExcTimes =  100000

class TestRunTime {
    static func runTests() {
        print("Running Use Time")
        
        measure("class (1 property)") {
            var x = Class1(0)
            for _ in 1...ExcTimes {
                x = x + Class1(1)
            }
        }
        
        measure("struct (1 property)") {
            var x = Struct1(0)
            for _ in 1...ExcTimes {
                x = x + Struct1(1)
            }
        }
        
        measure("class (10 propertys)") {
            var x = Class10(0)
            for _ in 1...ExcTimes {
                x = x + Class10(1)
            }
        }
        
        measure("struct (10 propertys)") {
            var x = Struct10(0)
            for _ in 1...ExcTimes {
                x = x + Struct10(1)
            }
        }
    }
    
    static private func measure(_ name: String, block: @escaping () -> ()) {
        print()
        print("\(name)")
        let t0 = CACurrentMediaTime()
        
        block()
        
        let dt = CACurrentMediaTime() - t0
        print("\(dt)")
    }
}

class用的时间几乎比struct多一倍

运行结果.png

2.官方例子，修改代码块，尽可能使用struct
例子1

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
    }
   ... 
}

//修改后
var cache = [Balloon : UIImage]()
func makeBalloon(_ balloon: Ballon) -> UIImage {
     if let image = cache[balloon] {
       return image
    }
   ... 
}

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

修改之后,调用makeBalloon方法,key就不会在对上创建与销毁

例子2

struct Attachment {
    let fileURL: URL
    // 修改前
    /*
    let uuid: String
    let mineType: String
    */
    //修改后
    let uuid: UUID
    let mineType: MimeType

    // 修改前
    // init?(fileURL: URL, uuid: String, mimeType: String) {
    // 修改后
    init?(fileURL: URL, uuid: String, mimeType: MimeType) {
       guard  mineType.isMineType else { 
           return nil
       }
       self.fileURL = fileURL 
       self.uuid = uuid 
       self.mineType = mimeType
   }
}

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

初始化器

struct会默认提供成员初始化器，类不会提供。

类中的成员变量初始化有值，不用提供初始化器，初始化时使用默认的初始化器，否则，必须提供指定初始化器。

class与struct初始化器.png

可以看到，如果类中有成员没有初始化，会爆错误，告诉你该类没有初始化。
此时，用两种修改方法，一种是给成员变量初始化，另一种是提供初始化器,但不能是便利初始化器

类的初始化器有多种：
1.默认初始化器:类都会提供默认初始化器。
2.指定初始化器：初始化成员的初始化方法，方法名是init，值得注意的是指定初始化器最好只有一个，如果有多个，请将其他的修改为便利初始化器。

class PersonClass {
    let id: String;
    var age: Int;
    
    init(_ id: String, _ age: Int){
        self.id = id
        self.age = age
    }
    
    init( _ age: Int){
        self.id = "id"
        self.age = age
    }
    
    init(_ id: String){
        self.id = id
        self.age = 12
    }

     //修改后
    convenience init( _ age: Int){
        self.init("id", age);
    }
    
    convenience init(_ id: String){
        self.init(id, 0)
        self.age = 12
    }
}

多个指定初始化器.png

3.必须初始化器：必须初始化器，是告知调用者或子类，你必须使用该方法进行初始化。init方法明前使用required关键字，他与指定初始化器只能有一个
4.便利初始化器：方法名init前加convenience关键字。注意2点：
4.1该初始化器必须调用一个非便利初始化器
4.2 调用了一个非便利初始化器后，才可以使用self.去修改成员变量的值

convenience init( _ age: Int){
    self.init("id", age);
}
    
convenience init(_ id: String){
    self.init(id, 0)
    self.age = 12
}

先访问self报错.png

5.可选/可失败初始化器：方法名init后加“?”,表示初始化器可以失败，返回nil

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

类与结构体探索1-定义、区别、初始化器