结构体
在 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）
结构体的初始化器
编译器会根据情况，可能会为结构体生成多个初始化器，宗旨是：保证所有成员都有初始值
初始化错误1
初始化错误2
初始化错误3
成员都有初始值
思考：下面代码能编译通过么？
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, 因此可以编译通过
自定义初始化器
一旦在定义结构体时自定义了初始化器，编译器就不会再帮它自动生成其他初始化器
窥探初始化器的本质
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.size) // 17
print(MemoryLayout.stride) // 24
print(MemoryLayout.alignment) // 8
类
类的定义和结构体类似，但编译器并没有为类自动生成可以传入成员值的初始化器.
编译器不会为类自动生成初始化器
和结构体比较:
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)
- 如果定义类没有给成员初始化值, 编译器不会生成无参的初始化器.
类的初始化器
- 如果类的所有成员都在定义的时候指定了初始值，编译器会为类生成无参的初始化器
- 成员的初始化是在这个初始化器中完成的
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 = 10
}
}
let p1 = Point()
结构体与类的本质区别
- 结构体是值类型（枚举也是值类型），类是引用类型（指针类型）
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是多少？ 10 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、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() {
var s1 = Size(width: 10, height: 20)
var s2 = s1
}
s2.width = 11
s2.height = 22
请问s1.width和s1.height是多少？
对象的堆空间申请过程
在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
var test = true
var y = 22
}
var p = Point()
class_getInstanceSize(type(of: p)) // 40
class_getInstanceSize(Point.self) // 40
引用类型的赋值操作
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, p内存16个字节不能修改
- let修饰的s, s内存8个字节不能修改,指向内存地址不变.
s.width和s.height修改的是堆里边内存
总结:
值类型和引用类型为常量时, 值类型和引用类型内存地址不能修改,不能指向其他内存.但引用类型可以修改其堆内存存储的成员变量值.
理解:
let声明值类型的字符串str, 说明常量str的内存是不能修改的,所以后边不能拼接字符串.
let声明值数组arr, 说明常量arr的内存是不能修改的,所以后边不能拼接,也不能修改某个元素的值.
嵌套类型
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 ♥
方法占用对象的内存么？
- 不占用
- 方法的本质就是函数
- 方法、函数都存放在代码段
思考：
思考以下结构体、类对象的内存结构是怎样的？
struct Point {
var x: Int
var b1: Bool
var b2: Bool
var y: Int
}
var p = Point(x: 10, b1: true, b2: true, y: 20)
class Size {
var width: Int
var b1: Bool
var b2: Bool
var height: Int
init(width: Int, b1: Bool, b2: Bool, height: Int) {
self.width = width
self.b1 = b1
self.b2 = b2
self.height = height
}
}
var s = Size(width: 10, b1: true, b2: true, height: 20)