6.结构体和类

亮哥666
166 阅读7分钟

结构体和类

结构体

在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，初始化方法、构造器、构造方法）。 其实也就是说上面的代码其实等效下面的代码

struct Date {
    var year: Int
    var month: Int
    var day: Int
    init(year: Int, month: Int, day: Int) {
        self.year = year
        self.month = month
        self.day = day
    }
}

在第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，因此可以编译通过。

自定义初始化器

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

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

结构体内存结构

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
  • size: 实际占用的内存大小
  • stride: 分配的内存大小（包含对齐）
  • alignment: 内存对齐

类

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

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 = 0
    var y: Int = 0
}
let p1 = Point()              // 类只能这样
// let p2 = Point(x: 10, 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 = 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()
}

image.png

值类型

值类型赋值给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 = 10, p1.y = 20（不受影响）
}

image.png

值类型的赋值操作示例

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

自己的总结

  • 结构体和类的本质是，结构体是值类型，而结构体是引用类型
  • 值类型赋值给var，let或者参数传参，是直接将所有内容都拷贝，类似于文件直接进行copy一份出来，产生了全新的文件副本。属于深拷贝。
  • 而且swift中绝大多数的公开类型都是结构体，比方说Bool、Int、Double、 String、Array、Dictionary这些都是结构体，这些直接使用 = 赋值就会产生一个新的副本

值类型的赋值操作

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

var p1 = Point(x: 10, y: 20)
p1 = Point(x: 11, y: 22)

内存变化：

  • 赋值前：p1.x = 10, p1.y = 20
  • 赋值后：p1.x = 11, p1.y = 22

image.png

引用类型

引用赋值给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（受影响）
}

image.png

对象的堆空间申请过程

在Swift中，创建类的实例对象，要向堆空间申请内存，大概流程如下：

  1. Class.__allocating_init()
  2. libswiftCore.dylib：_swift_allocObject_
  3. libswiftCore.dylib：swift_slowAlloc
  4. 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

引用类型的赋值操作

image.png

内存变化：

  • 原对象被销毁，s1指向新的对象
  • 栈空间地址改变，堆空间创建新对象

值类型、引用类型的let

image.png

let 就是代表p当前的内存不能修改，对于结构体来说p来说 x,y 都在p的内存中，p实际是占16 个字节，代表这16字节都不能修改 而对于对象来说，代表 s是常量， s的内存其实就是一个指针常量，只代表对象的地址不能改变，但是对面里面的width ,height 都不存在s中，是存在s指向的对象的堆里面，不是存在p这个变量里面，所以s不能修改，但是s里面的东西是可以改的

嵌套类型

就是说枚举可以嵌套在结构体内。

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 ♥

重要概念：

  • 一般把定义在枚举、结构体、类内部的函数，叫做方法
  • 方法占用对象的内存么？ 不占用
  • 方法的本质就是函数
  • 方法、函数都存放在代码段
  • 类里面的函数和最外层的函数本质没有啥区别，仅仅是作用域不同而已

结构体和类的存放位置问题

结构体变量的位置取决于他在哪里创建的，如果是对象里面创建，那么在堆空间，如果在函数里面创建，肯定是在内存空间。如果在最外层生命的，那么他就在全局区（数据段）

对于类里面，不论在那创建，指针变量指向的对象一定在堆空间，而指针变量如果是在函数里面定义的就在栈空间。 Pasted Graphic 7.tiff

其他笔记补充

1.arm64 架构里面

1.指针变量占8个字节 2. int 类型占 8个字节

2.对象里面在堆空间里面需要？
  1. 指向类型信息
  2. 引用计数
  3. 里面的存储对象成员变量的内存
3.判断是不是堆空间？

看看有没有调用 alloc malloc方法

4.si 什么作用？

可以跟进去 finish 调试的作用结束当前的调试，跳到下一个 端点

avatar
文章
阅读
粉丝