08-Swift结构体和类

结构体

• 在 Swift 标准库中，绝大多数的公开类型都是结构体，而枚举和类只占很小一部分
• Bool、Int、Double、 String、Array、Dictionary等常见类型都是结构体
• 结构体都有一个编译器自动生成的初始化器（initializer，初始化方法、构造器、构造方法）
• 结构体都有一个编译器自动生成的初始化器，编译器会根据情况，会为结构体生成多个初始化器
• 宗旨是：保证所有的成员都有初始值

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

structPoint{
varx: Int?  // 可选项都有个默认值nil
vary: Int?
}
varp1= Point(x: 10, y: 10)
varp2= Point(y: 10)
varp3= Point(x: 10)
varp4= Point()

1.自定义初始化器

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

struct TestPoint {
    var x: Int = 0
    var y: Int = 0
    var z: Bool = true
    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}

var testP1 = TestPoint(x: 10, y: 10)
//var p2 = TestPoint(y: 10)
//var p3 = TestPoint(x: 10)
//var p4 = TestPoint()

2.结构体内部结构

print(MemoryLayout<TestPoint>.size)         // 具体占用的内存大小
print(MemoryLayout<TestPoint>.stride)       // 系统分配的默认大小
print(MemoryLayout<TestPoint>.alignment)    // 对齐

类

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

class PointClass {
    var x: Int = 0
    var y: Int = 0
}

//let pc1 = PointClass()
//let pc1 = PointClass(x: 10, y: 20)
//let pc1 = PointClass(x: 10)
//let pc1 = PointClass(y: 20)

1.类的初始化器

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

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

//  等价于
classPoint{
  var x: Int
  var y: Int
   init() {
     x= 10
     y= 20
  }
}
let p1= Point()

2.结构体与类的本质区别

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

3.值类型

• 值类型赋值给var、let或者给函数传参，是直接将所有的内容拷贝一份

• 类似于对文件进行copy、paste操作，产生了全新的文件副本，属于深拷贝(deep copy)

  
  image.png

var s1 = "Jack"
var s2 = s1
print(String(format: "%p", s1))
print(String(format: "%p", s2))
s2.append("_Rose")
print(s1)
print(s2)
print(String(format: "%p", s1))
print(String(format: "%p", s2))

在Swift标准库中，为了提升性能，String，Array，Dictionary，Set采取了Copy On Write的技术
1.比如仅当有"写"操作时，才会真正进行拷贝操作
2.对于标准库值类型的赋值操作，Swift能够确保最佳性能，所以没必要为了保证最佳性能来避免赋值
3.建议：不需要修改的，尽量定义为let

4.引用类型

• 引用赋值给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是多少？
}

5.对象的堆空间申请过程

在Swift中，创建类的实例对象，要向堆空间申请内存，大概流程如下
Class.__allocating_init()
libswiftCore.dylib：_swift_allocObject_
libswiftCore.dylib：swift_slowAlloc
libsystem_malloc.dylib：malloc
在Mac、iOS中的malloc函数分配的内存大小总是16的倍数
通过class_getInstanceSize可以得知：类的对象至少需要占用多少内存

classPoint {
    var x= 11
    var test= true
    var y= 22
}
varp= Point()
class_getInstanceSize(type(of: p)) //40
class_getInstanceSize(Point.self) //40

6.值类型、引用类型的let

// 值类型、引用类型的let
struct TestPoint1 {
    var x: Int
    var y: Int
}

class TestSize1 {
    var width: Int
    var height: Int
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}
//let tp1 = TestPoint1(x: 10, y: 20)
//tp1 = Point(x: 11, y: 22)
//tp1.x = 33
//tp2.y = 44

//let ts1 = TestSize1(width: 10, height: 20)
//ts1 = TestSize1(width: 11, height: 22)
//ts1.width = 33
//ts1.height = 44

7.嵌套类型

struct Poker {
    enum Suit: Int {
        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

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

• 一般把定义在枚举、结构体、类内部的函数，叫做方法
• 方法不占用对象的内存空间
• 方法的本质就是函数
• 方法、函数都存放在代码段

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