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

结构体

1 结构体初识

• 所有结构体都有一个编译器自动生成初始化器（ininiallizer， 初始化方法、构造器、构造方法）示例：

struct Date {
    var year : Int
    var month : Int
    var day : Int
    
}
var date = Date(year: 2020, month: 07, day: 24)
 //这里只是定义了Date结构体，但是直接可以调用Date(year: 2020, month: 07, day: 24)

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

struct Point {
    var x : Int = 0
    var y : Int
    
}
var p1 = Point(x: 10, y: 20)  //正常
var p2 = Point(y: 20)//正常
var p2 = Point(x: 10)//报错 Missing argument for parameter 'y' in call

2. 自定义初始化器

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

struct Person {
    var name : String
    var age : Int
    init(name:String , age: Int) {
        self.name = name
        self.age = age
    }
}

---

类

1. 类初识

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

class Student {
    var name : String
    var age : Int
}

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

class Student {
    var name : String = "Jack"
    var age : Int = 0
    
}
var std = Student()

结构体 与 类 的本质区别（待补充）

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

• 值类型：值类型赋值给 var 、let 或者给函数传参，是直接将所有内容拷贝一份，属于深拷贝
• 引用类型： 引用赋值给 var、let或者给函数传参，是将内存地址拷贝一份，属于浅拷贝。

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

// 值类型赋值 ；String、Array、Dictionary、Set也是结构体类型，所以他们也属于值类型
struct Point {
    var x : Int = 0
    var y : Int
    
}
func test(){
    var p1 : Point = Point(x: 10, y: 20)
    var p2 : Point = p1
    
    p2.x = 22
    p2.y = 33
    
    print(p1)//Point(x: 10, y: 20)
}


var s1 = "jack"
var s2 = s1
s2.append("_hi")
print(s1)// jack
print(s2)//jack_hi

2. 值类型 、引用类型 的 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 po1 = Point(x: 10, y: 20)
po1 = Point(x: 2, y: 3)  //报错：Cannot assign to value: 'po1' is a 'let' constant
po1.x = 2 //报错：Cannot assign to value: 'po1' is a 'let' constant
po1.y = 3 //报错：Cannot assign to value: 'po1' is a 'let' constant

let si1 = Size(width: 10, height: 20)
si1 = Size(width: 2, height: 3)// 报错：Cannot assign to value: 'si1' is a 'let' constant
si1.width = 2
si1.height = 3

注意：对于引用类型 si ，其实存放的是一个地址，指向堆一个堆内存空间，
let si 指的是不能修改这个si指向的地址内存，si1.width = 2 si1.height 实际上是改的对应堆空间里面的值，并没有修改si的地址指向，所以并不会报错。

---

嵌套类型

  类似于内部类。如果某个类只在某个类里面使用时，则可以使用嵌套类型。

struct PersonObj {
    enum sex : String {
        case man = "1", woman = "2"
    }
    enum nation : Int {
        case hanzu = 1 , manzu = 2 , weiwuerzu = 3
    }
}

print(PersonObj.sex.man.rawValue)

var sextype = PersonObj.sex.man
sextype = .woman

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

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