类与结构体的定义
struct/class LGTeacher{
var age: Int
var name: String
init(age: Int, name: String)
{
self.age = age
self.name = name
}
deinit{
}
}
类与结构体定义，除了使用的关键字不同，其他看似相同，但有本质区别。
结构体和类的主要相同点有:
定义存储值的属性
定义方法
定义下标以使用下标语法提供对其值的访问
定义初始化器
使用 extension 来拓展功能
遵循协议来提供某种功能
主要的不同点有:
类有继承的特性，而结构体没有
类型转换使您能够在运行时检查和解释类实例的类型
类有析构函数用来释放其分配的资源
引用计数允许对一个类实例有多个引用
类是引用类型，结构体是值类型
对于类与结构体我们需要区分的第一件事就是:
类是引用类型。也就意味着一个类类型的变量并不直接存储具体的实例对象，是对当前存储具体实例内存地址的引用。
引用类型与值类型
引用类型，一个类类型的变量不直接存储具体的实例对象，而是存储当前实例对象的内存地址引用。
值类型，一个值类型的变量存储的就是具体的实例，换句话说，就是具体的值
回顾内存区域
栈区(stack): 局部变量和函数运行过程中的上下文
堆区(Heap): 存储所有对象
Global: 存储全局变量;
常量：TEXT.cstring、TEXT.const
代码区： Mach-O 文件中Text段中的__text
结合Mach-O类分析
Segment & Section: Mach-O 文件有多个段( Segment )，每个段有不同的功能。然后每 个段又分为很多小的 Section
TEXT.text : 机器码
TEXT.cstring : 硬编码的字符串
TEXT.const: 初始化过的常量
DATA.data: 初始化过的可变的(静态/全局)数据 DATA.const: 没有初始化过的常量
DATA.bss: 没有初始化的(静态/全局)变量
DATA.common: 没有初始化过的符号声明
验证结构体比类快
1.测试使用结构体、类创建各自使用的时间
import UIKit
let ExcTimes = 100000
class TestRunTime {
static func runTests() {
print("Running Use Time")
measure("class (1 property)") {
var x = Class1(0)
for _ in 1...ExcTimes {
x = x + Class1(1)
}
}
measure("struct (1 property)") {
var x = Struct1(0)
for _ in 1...ExcTimes {
x = x + Struct1(1)
}
}
measure("class (10 propertys)") {
var x = Class10(0)
for _ in 1...ExcTimes {
x = x + Class10(1)
}
}
measure("struct (10 propertys)") {
var x = Struct10(0)
for _ in 1...ExcTimes {
x = x + Struct10(1)
}
}
}
static private func measure(_ name: String, block: @escaping () -> ()) {
print()
print("\(name)")
let t0 = CACurrentMediaTime()
block()
let dt = CACurrentMediaTime() - t0
print("\(dt)")
}
}
2.官方例子，修改代码块，尽可能使用struct
例子1
enum Color { case blue, green, gray }
enum Orientation { case left, right }
enum Tail { case none, tail, bubble }
var cache = [String : UIImage]()
// 修改前
func makeBalloon(_ color: Color, _ orientation: Orientation, _ tail: Tail) -> UIImage {
let key = "\(color):\(orientation):\(tail)"
if let image = cache[key] {
return image
}
...
}
//修改后
var cache = [Balloon : UIImage]()
func makeBalloon(_ balloon: Ballon) -> UIImage {
if let image = cache[balloon] {
return image
}
...
}
struct Balloon: Hashable{
var color: Color
var orientation: Orientation
var tail: Tail
}
修改之后,调用makeBalloon方法,key就不会在对上创建与销毁
例子2
struct Attachment {
let fileURL: URL
// 修改前
/*
let uuid: String
let mineType: String
*/
//修改后
let uuid: UUID
let mineType: MimeType
// 修改前
// init?(fileURL: URL, uuid: String, mimeType: String) {
// 修改后
init?(fileURL: URL, uuid: String, mimeType: MimeType) {
guard mineType.isMineType else {
return nil
}
self.fileURL = fileURL
self.uuid = uuid
self.mineType = mimeType
}
}
enum MimeType: String{
case jpeg = "image/jpeg"
....
}
初始化器
struct会默认提供成员初始化器，类不会提供。
可以看到，如果类中有成员没有初始化，会爆错误，告诉你该类没有初始化。
此时，用两种修改方法，一种是给成员变量初始化，另一种是提供初始化器,但不能是便利初始化器
类的初始化器有多种：
1.默认初始化器:类都会提供默认初始化器。
2.指定初始化器：初始化成员的初始化方法，方法名是init，值得注意的是指定初始化器最好只有一个，如果有多个，请将其他的修改为便利初始化器。
class PersonClass {
let id: String;
var age: Int;
init(_ id: String, _ age: Int){
self.id = id
self.age = age
}
init( _ age: Int){
self.id = "id"
self.age = age
}
init(_ id: String){
self.id = id
self.age = 12
}
//修改后
convenience init( _ age: Int){
self.init("id", age);
}
convenience init(_ id: String){
self.init(id, 0)
self.age = 12
}
}
3.必须初始化器：必须初始化器，是告知调用者或子类，你必须使用该方法进行初始化。init方法明前使用required关键字，他与指定初始化器只能有一个
4.便利初始化器：方法名init前加convenience关键字。注意2点：
4.1该初始化器必须调用一个非便利初始化器
4.2 调用了一个非便利初始化器后，才可以使用self.去修改成员变量的值
convenience init( _ age: Int){
self.init("id", age);
}
convenience init(_ id: String){
self.init(id, 0)
self.age = 12
}
5.可选/可失败初始化器：方法名init后加“?”,表示初始化器可以失败，返回nil
这里我们记住:
1 指定初始化器必须保证在向上委托给父类初始化器之前，其所在类引入的所有属性都要初始化完成。
2 指定初始化器必须先向上委托父类初始化器，然后才能为继承的属性设置新值。如果不这样做，指定初始化器赋予的新值将被父类中的初始化器所覆盖
3 便捷初始化器必须先委托同类中的其它初始化器，然后再为任意属性赋新值(包括 同类里定义的属性)。如果没这么做，便捷构初始化器赋予的新值将被自己类中其它指定初始化器所覆盖。
4 初始化器在第一阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用 self 作为值。
