Swift-结构体和类

结构体

在 Swift 标准库中，绝大多数的公开类型都是结构体，而枚举和类只占很小一部分
比如Bool、Int、Double、 String、Array、Dictionary等常见类型都是结构体
所有的结构体都有一个编译器自动生成的初始化器（initializer，初始化方法、构造器、构造方法）

在第⑥行调用的，可以传入所有成员值，用以初始化所有成员（存储属性，Stored Property）

① struct Date { 
②   var year: Int
③   var month: Int
④   var day: Int
⑤ } 
⑥ var date = Date(year: 2019, month: 6, day: 23)

结构体的初始化器

编译器会根据情况，可能会为结构体生成多个初始化器，宗旨是：保证所有成员都有初始值

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

struct Point1 {
    var x: Int = 0
    var y: Int
}
var p1 = Point1(x: 10, y: 20)
var p3 = Point1(y: 20)
//var p2 = Point1(x: 10)   x
//var p4 = Point1()        x

struct Point3 {
    var x: Int = 0
    var y: Int = 0
}
var p1 = Point(x: 10, y: 20)
var p2 = Port(x: 10)
var p3 = Port(y: 20)
var p4 = Point()

自定义初始化器

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

struct Point {
    var x: Int = 0
    var y: Int = 0
    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}
var p1 = Point(x: 10, y: 20)
//var p2 = Port(x: 10)        x
//var p3 = Port(y: 20)        x
//var p4 = Point()            x

窥探初始化器的本质

以下2段代码完全等效

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

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

结构体内存结构

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

类

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

// 类
class Point {
    var x: Int = 0
    var y: Int = 0
}
let p1 = Point()
//let p2 = Point(x: 10, y: 20)     x
//let p3 = Point(x: 10)            x
//let p4 = Point(y: 20)            x

// 结构体
struct Point {
    var x: Int = 0
    var y: Int = 0
}
let p1 = Point()
let p2 = Point(x: 10, y: 20)
let p3 = Point(x: 10)
let p4 = Point(y: 20)

// 类
struct Point {
    var x: Int
    var y: Int
}
// let p1 = Point() x 不能初始化成功，成员没有初始值

类的初始化器

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

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()

上面2段代码是完全等效的

结构体与类的本质区别

结构体是==值类型==（枚举也是值类型），类是==引用类型==（指针类型）

class Size {
    var width = 1
    var height = 2
}
struct Point {
    var x = 3
    var y = 4
}
func test() {
    var size = Size()
    var point = Point()
}

值类型

值类型赋值给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和p1.y是多少？
// p1.x和p1.y的值仍然是10，20，p2为深拷贝，修改p2不影响p1

值类型的赋值操作

//字符串String
var s1 = "Jack"
var s2 = s1
s2.append("_Rose")
print(s1) // Jack
print(s2) // Jack_Rose

//数组Array
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]

// 字典Dictionary
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、Dictionary、Set采取了==Copy On Write==的技术
比如仅当有“写”操作时，才会真正执行拷贝操作
对于标准库值类型的赋值操作，Swift能确保最佳性能，所有没必要为了保证最佳性能来避免赋值
建议：不需要修改的，尽量定义成let

引用类型

引用赋值给var、let或者给函数传参，是将==内存地址拷贝一份==

类似于制作一个文件的替身（快捷方式、链接），指向的是同一个文件。属于==浅拷贝==（shallow copy）

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
}

s2.width = 11
s2.height = 22
// 请问s1.width和s1.height是多少？
// s1.width=11 s1.height=22，两个对象(局部变量)地址不一样，但是变量所对应的堆空间的地址是一样，所以修改一个对象的值，另一个也是改变的。

对象的堆空间申请过程

在Swift中，创建类的实例对象，要向堆空间申请内存，大概流程如下：
- Class.__allocating_init()
- libswiftCore.dylib：==swift_allocObject==
- libswiftCore.dylib：==swift_slowAlloc==
- libsystem_malloc.dylib：==malloc==
在Mac、iOS中的malloc函数分配的内存大小总是16的倍数

通过class_getInstanceSize可以得知：类的对象至少需要占用多少内存

class Point {
    var x = 11          //8个字节
    var test = true     //1个字节，考虑到内存对齐所以占用8个字节，实际使用1个字节
    var y = 22          //8个字节
}
var p = Point()
class_getInstanceSize(type(of: p)) // 40
class_getInstanceSize(Point.self) // 40
malloc_size(p)  //48
// 对象在内存中有一个指向类型信息和引用计数各占8个字节。
// 通过malloc_size分配的为48，因malloc函数分配的内存大小总是16的倍数。

引用类型的赋值操作

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)       x
//p.x = 33                      x
//p.y == 44                     x

let s = Size(width: 10, height: 20)
//s = Size(width: 11, height: 22)       x
s.width = 33
s.height = 44

let str = "Jack"
//str.appending("_Rose")    x

let array = [1, 2, 3]
//array[0] = 4              x
//array.append(5)           x

嵌套类型

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.hearts.rawValue)
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()
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 ♥