七、结构体

//1.结构体
//在swift标准库中，绝大多数的公开类型都是结构体，而枚举和类只占很小一部分,比如Bool、Int、Double、String、Array、Dictionary等常见类型都是结构体，所有结构体都有一个编译器自动生成的初始化器（initializer、初始化方法、构造器、构造方法）
struct Date {
    var year: Int //存储属性
    var month: Int
    var day: Int
}
var date = Date(year: 2020, month: 9, day: 15)//可以传入所有成员值，用以初始化所有成员(存储属性)
//2.结构体的初始化器，编译器会根据情况，可能会为结构体生成多个初始化器，宗旨是：保证所有成员都有值
struct Point0 {
    var x: Int
    var y: Int
}
var p1 = Point0(x: 10, y: 10)
//var p2 = Point0(y: 10) //3行都编译不通过
//var p3 = Point0(x: 10)
//var p4 = Point0()

struct Point1 {
    var x: Int = 0
    var y: Int
}
var pp1 = Point1(x: 10, y: 10)
var pp2 = Point1(y: 10)
//var pp3 = Point1(x: 10)
//var pp4 = Point1()

struct Point2 {
    var x: Int = 0
    var y: Int = 0 //生成了4个初始化器
}
var ppp1 = Point2(x: 10, y: 10)
var ppp2 = Point2(y: 10)
var ppp3 = Point2(x: 10)
var ppp4 = Point2()

//3.思考下面的代码能编译通过么？可选项都有个默认值nil，因此可以编译通过
struct Point3 {
    var x: Int?
    var y: Int?
}
var pppp1 = Point3(x: 10, y: 10)
var pppp2 = Point3(y: 10)
var pppp3 = Point3(x: 10)
var pppp4 = Point3()

//4.自定义初始化器
//一旦在定义结构体时自定义了初始化器，编译器就不会再帮它自动生成其他初始化器
struct Point4 {
    var x: Int = 0
    var y: Int = 0
    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }
}
var t1 = Point4(x: 10, y: 10)
//var t2 = Point4(y: 10)
//var t3 = Point4(x: 10)
//var t4 = Point4()

//5.窥探初始化器的本质
struct Point5 {
    var x: Int = 0
    var y: Int = 0
}
var m = Point5()
/*
 TestSwift`Point5.init():
 ->  0x100004080 <+0>:  pushq  %rbp
     0x100004081 <+1>:  movq   %rsp, %rbp
     0x100004084 <+4>:  xorps  %xmm0, %xmm0
     0x100004087 <+7>:  movaps %xmm0, -0x10(%rbp)
     0x10000408b <+11>: movq   $0x0, -0x10(%rbp)
     0x100004093 <+19>: movq   $0x0, -0x8(%rbp)
     0x10000409b <+27>: xorl   %eax, %eax
     0x10000409d <+29>: movl   %eax, %ecx
     0x10000409f <+31>: movq   %rcx, %rax
     0x1000040a2 <+34>: movq   %rcx, %rdx
     0x1000040a5 <+37>: popq   %rbp
     0x1000040a6 <+38>: retq   
 */
//等价于
struct Point6 {
    var x: Int
    var y: Int
    init() {
        x = 0
        y = 0
    }
}
var n = Point6()
/*
 TestSwift`Point6.init():
 ->  0x100004140 <+0>:  pushq  %rbp
     0x100004141 <+1>:  movq   %rsp, %rbp
     0x100004144 <+4>:  xorps  %xmm0, %xmm0
     0x100004147 <+7>:  movaps %xmm0, -0x10(%rbp)
     0x10000414b <+11>: movq   $0x0, -0x10(%rbp)
     0x100004153 <+19>: movq   $0x0, -0x8(%rbp)
     0x10000415b <+27>: xorl   %eax, %eax
     0x10000415d <+29>: movl   %eax, %ecx
     0x10000415f <+31>: movq   %rcx, %rax
     0x100004162 <+34>: movq   %rcx, %rdx
     0x100004165 <+37>: popq   %rbp
     0x100004166 <+38>: retq
 */

//6.结构体内存结构
struct Point7 {
    var x: Int = 0
    var y: Int = 0
    var oringin: Bool = false
}
print(MemoryLayout<Point7>.stride) //17
print(MemoryLayout<Point7>.size) //24
print(MemoryLayout<Point7>.alignment) //8

//7.类
//类的定义和结构体类似，但编译器并没有为类自动生成可以传入成员值的初始化器
class Point {
    var x: Int = 0
    var y: Int = 0
}
let b1 = Point()
//let b2 = Point(x: 10, y: 10) 不管有没=0都编译不过
//let b3 = Point(x: 10)
//let b4 = Point(y: 10)

//8.类的初始化器
//如果类的所有成员都在定义的时候指定了初始值，编译器会为类生成无参的初始化器，成员的初始化是在这个初始化器中完成的
class Point8 {
    var x: Int = 10
    var y: Int = 20
}
let b8 = Point8()
//等价于
class Point9 {
    var x: Int
    var y: Int
    init() {
        x = 10
        y = 20
    }
}
let b9 = Point9()

//9.结构体和类的本质区别
//结构体和枚举都是值类型，类是引用类型（指针类型）,引用类型的地址在栈，地址的内存在堆，包含了指向类型信息、引用计数、成员数据。
class Size {
    var width = 1
    var height = 2
}
struct Point10 {
    var x = 3
    var y = 4
}
var size0 = Size()
print("size0变量的地址",Mems.ptr(ofVal: &size0))//0x000000010000fb38
print("size0变量的内存",Mems.memStr(ofVal: &size0))//0x0000000100556ea0
print("size0所指向内存的地址",Mems.ptr(ofRef: size0))//0x0000000100556ea0
print("size0所指向内存的内容",Mems.memStr(ofRef: size0))//0x000000010000f7f0 0x0000000200000002 0x0000000000000001 0x0000000000000002
var point0 = Point10()
print("point0变量的地址",Mems.ptr(ofVal: &point0))//0x000000010000fb40
print("point0变量的内存",Mems.memStr(ofVal: &point0))//0x0000000000000003 0x0000000000000004

//-0x10(%rbp) 局部变量 栈空间， 0x712a(%rip) 全局变量 全局区, 0x10(%rax) 一般是堆空间

//10.值类型
//1值类型赋值给var、let或者给函数传参，是直接将所有内容拷贝一份，类似于对文件copy、paste操作，产生了全新的文件副本。属于深拷贝
//2在swift标准库中，为了提升性能String、Array、Dictionary、set采取了copy on write技术，比如仅当有写操作时，才会真正执行拷贝操作，对于标准库类型的赋值操作，swift能确保包最佳性能，所以没必要为了保证最佳性能来避免赋值，建议不需要修改的尽量定义成let
var s1 = "Jack"//深拷贝
var s2 = s1
s2.append("Rose") //没有这一句上面第二句是浅拷贝，有这一句则是深拷贝
print(s1)//Jack
print(s2)//JackRose

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)//["max": 10, "min": 2, "other": 7]
print(d2)//["max": 12, "min": 2]

//11.值类型的重新赋值操作
struct Point11 {
    var x: Int
    var y: Int
}
var c1 = Point11(x: 10, y: 20)
c1 = Point11(x: 11, y: 21)//栈内存值的覆盖

//12.引用类型 浅拷贝
func aa() {
    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)
    let s2 = s1
    
    s2.width = 11
    s2.height = 22//s1.width = 11, s1.height = 22
}
aa()

//13.引用类型的赋值操作 是引用地址的堆空间内存重新赋值
//14.对象的堆空间申请过程
/*
 （1）.在swift中，创建类的实例对象，要向堆空间申请内存，最终会调用malloc，大概流程如下
 Class.__allocating_init()
 libswiftCore.dylib.swift_allocObject:
 libswiftCore.dylibswift_slowAlloc:
 libsystem_malloc.dylib`malloc:
（2）在Mac、iOS中的malloc函数分配的内存大小总是16的倍数
 (3)通过class_getInstanceSize可以得知：类的对象至少需要占用多少内存
 */
func bb(){
    class Point {
        //指向类型信息、引用计数16
        var x = 11 //8
        var test = true //1
        var y = 22 //8
    }//实际用了33，加上对齐至少需要40,堆空间malloc分配了48
    var p = Point()
    class_getInstanceSize(type(of: p))//40
    class_getInstanceSize(Point.self)//40
    print(Mems.size(ofRef: p))//48
}
bb()

//15.值类型、引用类型的let
func cc(){
    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 = Point(x: 10, y: 10)
//    p = Point(x: 11, y: 22)//常量不能二次赋值
//    p.x = 33//常量的前8个字节不能赋值
//    p.y = 44//常量的后8个字节不能赋值
    
    let s = Size(width: 10, height: 20)
//    s = Size(width: 11, height: 22)//常量不能二次赋值
    s.width = 33 //s存储的地址指向的内存空间可以重新赋值
    s.height = 44
}
cc()

//16.嵌套类型
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 //diamonds
var rank = Poker.Rank.five
rank = .king //king

//17.枚举、结构体、类都可以定义方法
//一般把定义在枚举、结构体、类内部的函数叫做方法，方法占用对象的内存么？不占用，方法的把本质就是函数，方法函数不管放在内部还是外部都放在代码段
func dd() {
    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()
    
}
dd()

//18.思考以下结构体、类对象的内存结构是怎么样的？
func ee() {
    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)
    print(MemoryLayout<Point>.stride)//24
    print(MemoryLayout<Point>.size)//24 ？
    print(MemoryLayout<Point>.alignment)//8
    
    class Size {
        //指向类型信息、引用计数16,很容易忘记
        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)
    print(class_getInstanceSize(Size.self))//48非32
    print(Mems.size(ofRef: s))//48
}
ee()