结构体

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

struct Date {
    var year: Int
    var month: Int
    var day: Int
}
var date = Date(year: 2019, month: 6, day: 23)

• 所有的结构体都有一个编译器自动生成的初始化器(initializer，初始化方法、构造器、构造方法)
  • 初始化结构体，可以传入所有成员值，用以初始化所有成员(存储属性，Stored Property)

结构体的初始化器

• 编译器会根据情况，可能会为结构体生成多个初始化器，宗旨是:保证所有成员都有初始值
  初始化错误一
  赋值x默认值后初始化
  赋值y默认值后初始化
  赋值所有默认值后初始化
• 可选项都有默认值nil，因此下面代码可以通过编译

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

自定义初始化器

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

  
  自定义初始化器后，其他初始化方法失败

窥探初始化器的本质

• 以下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()

类

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

  
  类没有默认可以传入成员值的初始化器
  类初始化失败

类的初始化器

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

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)

值类型的赋值操作

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、Dictionary、Set采取了Copy On Write的技术
  • 比如仅当有“写”操作时，才会真正执行拷贝操作
  • 对于标准库值类型的赋值操作，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或者给函数传参，是将内存地址拷贝一份
  • 类似于制作一个文件的替身(快捷方式、链接)，指向的是同一个文件。属于浅拷贝(shallow copy)

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

    }
}

func test() {
    let s1 = Size(width: 10, height: 20)
    let s2 = s1
    s2.width = 11
    s2.height = 22
//请问s1.width和s1.height是多少
}

引用赋值内存空间

引用类型的赋值操作

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报错的区别
值类型的let修改报错

嵌套类型

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 ♥

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