结构体

• 在Swift标准库中，绝大多数的公开类型都是结构体，而枚举和类只占很小一部分
• 比如Bool、Int、Double、String、Array、Dictionary等常见类型都是结构体

1、struct Data {
2、    var year:Int
3、    var month:Int
4、  var day:Int
5、}
6、var date = Data(year: 2019, month: 6, day: 23)

• 所有的结构体都有一个编译器自动生成的初始化器（initializer，初始化方法，构造器，构造方法）
• 在第6行调用的，可以传入所有成员值，用以初始化所有成员（存储属性，Stored Property）
• 编译器会根据情况，可能会为结构体生成多个初始化器，宗旨是：保证所有成员都有初始值
  
  
  
  
  
  
  

struct Point {
    var x:Int?
    var y:Int?
}
var p1 = Point(x: 10, y: 10)
var p2 = Point(y:10)
var p3 = Point(x:10)
var p4 = Point()

• 上述代码可以编译通过，因为可选项都有个默认值nil

• 一旦在定义结构体时自定义了初始化器，编译器就不会再帮它自动生成其他初始化器

  
  

初始化器

• 所有的结构体都有一个编译器自动生成的初始化器（initializer，初始化方法）
• 类需要自己生成有成员值的初始化器，Swift中创建类和结构体的实例时必须为所有的存储属性设置一个合适的初始值。所以类必须要提供对应的指定初始化器，同时我们也可以为当前的类提供便捷初始化器（注意：便捷初始化器必须从相同的类里调用另一个初始化器）

class LGPerson {
    var age:Int
    var name:String
    init(_ age:Int,_ name:String) {
        self.age = age
        self.name = name
    }
    convenience init(_ age:Int){//便捷初始化器
        self.init(18,"kody")
        self.age = age
        self.name = ""
    }
}

注意点

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

class LGPerson {
    var age:Int
    var name:String
    init(_ age:Int,_ name:String) {
        self.age = age
        self.name = name
    }
    convenience init(_ age:Int){//便捷初始化器
        self.init(18,"kody")
        self.age = age
        self.name = ""
    }
}
class LGTeacher:LGPerson{
  var subjectName:String
  init (_ subjectName: String){
    self.subjectName = subjectName
    super.init(18,"awe")
  }
}

• 可失败初始化器：当前因为参数的不合法或者外部条件的不满足，存在初始化失败的情况。这种Swift中可失败初始化器写return nil语句，来表明可失败初始化器在何种情况下会触发初始化失败。写法如下：

class LGPerson {
    var age:Int
    var name:String
    init?(age:Int,name:String) {
        if age<18 {return nil}
        self.age = age
        self.name = name
    }
}

• 必要初始化器：在类的初始化器前添加required修饰符来表明所有该类的子类都必须实现该初始化器

初始化器的本质

struct Point {
    var x:Int = 0
    var y:Int = 0
}
var p1 = Point()

struct Point {
    var x:Int
    var y:Int
    init(){
      self.x = 0
      self.y = 0
    }
}
var p1 = Point()

上面两段代码完全等效

结构体内存结构

struct Point {
    var x:Int = 0
    var y:Int = 0
    var origin:Bool = false
    
}
var p1 = Point()
print(MemoryLayout<Point>.size)//17
print(MemoryLayout<Point>.stride)//24
print(MemoryLayout<Point>.alignment)//8

结构体和类的主要相同点

• 定义存储值的属性
• 定义方法
• 定义下标以使用下标语法提供对其值的访问
• 定义初始化值
• 使用extension来拓展功能
• 遵循协议来提供某种功能

结构体和类的主要不同点

• 类有继承的特性，而结构体没有
• 类型转换使您能够在运行时检查和解释类实例的类型
• 类有析构函数用来释放其分配的资源
• 引用计数允许对一个类实例有多个引用

结构体与类的本质区别

• 类是引用类型（指针类型），也就意味着一个类类型的变量并不直接存储具体的实例对象，是对当前存储具体实例内存地址的引用
• 结构体是值类型（枚举也是值类型），相比较类类型的变量中存储的是地址，那么值类型存储的就是具体的实例（或者说具体的值）

类举例

• 类的定义和结构体类似，但编译器并没有为类自动生成可以传入成员值的初始化器

  
  
  
  
• 如果类的所有成员都在定义的时候指定了初始值，编译器会为类生成无参的初始化器
• 成员的初始化是在这个初始化器中完成的

class Point {
    var x:Int = 10
    var y:Int = 20
}
let p1 = Point()

class Point {
    var x:Int
    var y:Int
    init() {
        x = 10
        y = 20
    }
}
let p1 = Point()

上面两段代码完全等效

• 上图都是针对64bit环境
  lldb指令：
po/p:po和p的区别在于使用po只会输出对应的值，而p则会返回值的类型以及命令结果的引用名
x/8g:读取内存中的值（8g：8字节格式输出）

class LGTeacher {
    var age:Int
    var name:String
    init(age:Int,name:String) {
        self.age = age
        self.name = name
    }
}
var t = LGTeacher(age: 18, name: "Kody")
var t1 = t;

print("end")//打断点

lldb

(lldb) po t
<LGTeacher: 0x10064e3d0>

(lldb) po t1
<LGTeacher: 0x10064e3d0>

(lldb) x/8g 0x10064e3d0
0x10064e3d0: 0x0000000100008180 0x0000000600000003
0x10064e3e0: 0x0000000000000012 0x0000000079646f4b
0x10064e3f0: 0xe400000000000000 0x0000000000000000
0x10064e400: 0x00000009a0080001 0x00007fff817025c8

(lldb) po withUnsafePointer(to: &t, {print($0)})  //获取t的地址
0x0000000100008218
(lldb) po withUnsafePointer(to: &t1, {print($0)})  //获取t1的地址
0x0000000100008220

• 静态的存储属性（static），也就是类型存储属性，他在程序运行过程中，只初始化一次，因为本质就是全局变量，全局变量在运动过程中只初始化一次，而且static修饰的属性默认是lazy的

结构体举例

struct LGTeacher {
    var age:Int
    var name:String
    init(age:Int,name:String) {
        self.age = age
        self.name = name
    }
}
var t = LGTeacher(age: 18, name: "Kody")
var t1 = t;

print("end")

lldb

(lldb) po t
▿ LGTeacher
  - age : 18
  - name : "Kody"

(lldb) po t1
▿ LGTeacher
  - age : 18
  - name : "Kody"

值类型

• 值类型赋值给var、let或者给函数传参，是直接将所有内容拷贝一份
• 类似于对文件进行copy、paste操作，产生了全新的文件副本。属于深拷贝（deep copy）

• 值类型存储在栈上

  
  

struct Point {
    var x:Int
    var y:Int
}

func test()  {
    var p1 = Point(x: 10, y: 20)
    var p2 = p1
    p2.x = 11
    p2.y = 22
//p1.x是10，p1.y是20
}

值类型的赋值操作

var s1 = "jack"
var s2 = s1
s2.append("_Rose")
print(s1)//jack
print(s2)//jack_Rose

var a1 = [1,2,3]
var a2 = a1
a2.append(4)
a1[0] = 2
print(a1)//[2,2,3]
print(a2)//[1,2,3,4]

var d1 = ["max":10,"min":2]
var d2 = d1
d1["other"] = 7
d2["max"] = 12
print(d1)//["other":7,"max":10,"min":2]
print(d2)//["max":12,"min":2]

• 在Swift标准库中，为了提升性能，String、Array、Dictiionary、Set采取了Copy On Write技术，以String为例

var s1 = "Jack"
var s2 = s1
如果后续的代码，没有对s1和s2做修改，则s1和s2指向同一地址，即浅拷贝，如果后续有对s1或者s2做数据修改，则s1和s2会开出不同的地址做存储，则深拷贝

• 比如仅当有“写”操作时，才会真正执行拷贝操作
• 对于标准库值类型的赋值操作，Swift能确保最佳性能，所以没必要为了保证最佳性能来避免赋值
• 建议：不需要修改的，尽量定义成let

struct Point {
    var x:Int
    var y:Int
}
var p1 = Point(x: 10, y: 20)
p1 = Point(x: 11, y: 22)
存储地址是一样的，只是替换值

引用类型

• 引用赋值给var、let或者给函数传参，是将内存地址拷贝一份
• 类似于制作一个文件的替身（快捷方式、链接），指向的是同一个文件，属于浅拷贝
• 引用类型存储在堆上

class Size {
    var width:Int
    var height:Int
    init(width:Int,height:Int) {
        self.width = width
        self.height = height
    }
}

func test() {
    var s1 = Size(width: 10, height: 20)
    var s2 = s1
}

内存区域

栈区（Stack）：局部变量和函数运行过程中的上下文
堆区（Heap）：存储所有对象
全局区（Global））（全局区也可以细分为全局区、常量区、text指令区）：存储全局变量、常量、代码区
Segment&Section：Mach-o文件有多个段（segment），每个段有不同的功能，然后每个段又分为很多小的section
TEXT.text :机器码
TEXT.cstring:硬编码的字符串
TEXT.const:初始化过的常量
DATA.data:初始化过的可变的（静态/全局）数据
DATA.const:没有初始化过的常量
DATA.bss:没有初始化的（静态/全局）变量
DATA.common:没有初始化过的符号声明

引用类型的赋值操作

class Size {
    var width:Int
    var height:Int
    init(width:Int,height:Int) {
        self.width = width
        self.height = height
    }
}
var s1 = Size(width: 10, height: 20)
s1 = Size(width: 11, height: 22)

值类型、引用类型的let

struct Point {
    var x:Int
    var y:Int
}

class Size {
    var width:Int
    var height:Int
    init(width:Int,height:Int) {
        self.width = width
        self.height = height
    }
}

let p = Point(x: 10, y: 20)
p = Point(x: 11, y: 22)//error:Cannot assign to value: 'p' is a 'let' constant
p.x = 33//error:Cannot assign to property: 'p' is a 'let' constant
p.y = 44//error:Cannot assign to property: 'p' is a 'let' constant

let s = Size(width: 10, height: 20)
s = Size(width: 11, height: 22)//error:Cannot assign to value: 's' is a 'let' constant
s.width = 33
s.height = 44

let str = "Jac"
str.append("ss")//error:Cannot use mutating member on immutable value: 'str' is a 'let' constant

let arr = [1,2,3]
arr[0] = 11//error:Cannot assign through subscript: 'arr' is a 'let' constant
arr.append(4)//error:Cannot use mutating member on immutable value: 'arr' is a 'let' constant

嵌套类型

struct Poker {
    enum Suit:Character {
        case spades = "♠️",hearts = "♥️",diamonds = "♦️",clubs = "♣️"
    }
    enum Rank:Int {
        case two = 2,three,four,five,six,seven,eight,nine,ten
        case jack,queen,king,ace
    }
}
print(Poker.Suit.spades)//spades
var suit = Poker.Suit.spades
suit = .diamonds
var rank = Poker.Rank.five
rank = .king

枚举、结构体、类都可以定义方法

• 一般把定义在枚举、结构体、类内部的函数，叫做方法

class Size {
    var width = 10
    var height = 10
    func show() {
        print("width = \(width),height = \(height)")
    }
}
let s = Size()
s.show()//width = 10,height = 10

struct Point {
    var x = 10
    var y = 10
    func show() {
       print("x = \(x),y = \(y)")
    }
}
let p = Point(x: 10, y: 10)
p.show()//x = 10,y = 10

enum PokerFace:Character {
    case spades = "♠️",hearts = "♥️",diamonds = "♦️",clubs = "♣️"
    func show() {
        print("face is \(rawValue)")
    }
}
let pf = PokerFace.hearts
pf.show()//face is ♥️

• 方法不占用对象的内存
• 方法的本质就是函数，方法、函数都存放在代码段

异变方法

Swift中class和struct都能定义方法，但是有一点区别的是默认情况下，值类型属性不能被自身的实例方法修改

struct Point {
    var x = 0.0,y = 0.0
    func moveBy(x deltaX:Double,y deltaY:Double)  {
        x += deltaX//error:Left side of mutating operator isn't mutable: 'self' is immutable
        y += deltaY//error:Left side of mutating operator isn't mutable: 'self' is immutable
    }
}
var p = Point()
p.moveBy(x:10.0, y:20.0)

想要修改，需要在func前边添加mutating，如下：

struct Point {
    var x = 0.0,y = 0.0
    mutating func moveBy(x deltaX:Double,y deltaY:Double)  {
        x += deltaX
        y += deltaY
    }
}
var p = Point()
p.moveBy(x:10.0, y:20.0)

异变方法的本质：对于异变方法，传入的self被标记为inout参数。无论在mutating方法内部发生什么，都会影响外部依赖类型的一切。

输入输出参数：如果我们想函数能够修改一个形式参数的值，而且希望这些改变在函数结束之后依然生效，那么就需要将形式参数定义为输入输出形式参数。在形式参数定义开始的时候在前边添加一个inout关键字可以定义一个输入输出形式参数。

var age = 10
func modifyage(_ age:Int){
    age += 1//error:Left side of mutating operator isn't mutable: 'age' is a 'let' constant
报错：因为函数的形式参数都是let类型的常量
}

如果想内部修改age，并且影响外部age值，可以如下写法
var age = 10
func modifyage(_ age:inout Int){
    age += 1
}
modifyage(&age)

方法调度

方式总结：

影响函数派发方式

• final：添加了final关键字的函数无法被重写，使用静态派发，不会在vtable中出现，且对objc运行时不可见
• dynamic：函数均可添加dynamic关键字，为非objc类和值类型的函数赋予动态性，但派发方式还是函数表派发
• @objc：该关键字可以将Swift函数暴露给Objc运行时，依旧是函数表派发
• @objc+dynamic:消息派发的方式

内联函数

函数内联是一种编译器优化技术，它通过使用方法的内容替换直接调用该方法，从而优化性能

• 将确保有时内联函数。这是默认行为，我们无需执行任何操作，Swift编译器可能会自动内联函数作为优化
• always- 将确保始终内联函数，通过在函数前添加@inline(__always)来实现此行为
• never - 将确保永远不会内联函数。这可以通过在函数前添加@inline(never)来实现
• 如果函数很长并且想避免增加代码段大小，请使用 @inline(never)
  如果对象只在声明的文件中可见，可以用private或fileprivate进行修饰。编译器会对private或fileprivate对象进行检查，确保没有其他继承关系的情形下，自动打上final标记，进而使得对象获得静态派发的特性（fileprivate：只允许在定义的源文件中访问，private：定义的声明中访问）