swift结构体和类

一.结构体

1. 所有结构体都有一个编译器自动生成的初始化器。
2. 初始化时可以传入所有成员值用来初始化所有成员（存储属性）。
3. 结构体可能会生成多个初始化器，目的是保证所有成员都有初始值。（在编译器角度保证代码的安全。）
4. 在成员值没有默认值的时候，需要传入所有成员变量的值。
5. 自定义初始化器：一旦自定义了，编译器就不会自动生成其他初始器。

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

6. 结构体在函数中定义的话，他的内存在栈空间中。
7. 如果在函数外，定义全局变量中，存在数据段中，是一个全局变量。
8. 如果定义在类中，那会跟随类存在堆中。

二.类

1. 类的定义和结构体类似，但是编译器并没有为类自动生成可以传入成员值的初始化器。会生成一个无参的初始化器，
2. 类中有初始值的话无参初始化器才会有用。
3. 类无论在什么地方创建，他的值都在堆空间。
4. 类的指针内存如果在函数中定义，在栈空间，在全局中定义，在数据段。

三.结构体和类的本质区别

1.相同点

1. 在swift中，结构体和类都可以定义方法。（c++也可以）

2.不同点

1. 结构体是值类型(枚举也是值类型)，类是引用类型。

• 函数调用数据在栈空间中。
• 指针变量的地址在栈空间。
• 指针变量的数据在堆空间。

2. 如果在堆空间，汇编中会有alloc或者malloc函数，可以看到注释：

• __allocating_init()，代表在对空间申请内存。
• 进入这个init，会发现一个swift_allocObject，打上断点进入。
• 深入直至发现swift_slowAlloc，进入swift_slowAlloc。
• 可以看到一句

callq  0x7fff6865028c; symbol stub for: malloc

这是系统级别的分配堆空间的函数。在siwft和oc之中，都是调用malloc来分配内存的。

• 继续深入，最后调用到ibsystem_malloc.dylib`malloc，在这个函数中分配了堆空间的内存。

//实验代码：
func Class_and_Struct_Test(){
    class Size{
        var width = 1
        var height = 2
    }
    struct Point{
        var x = 3
        var y = 4
    }
    var size = Size() //指针变量占了8字节
    var point = Point() //这个结构体占了16字节
}

然后查看他们的内存

类的栈空间——————————————————————
size变量的地址： 0x00007ffeefbff440  //这个位置紧挨在point之后，差了16位
size变量的内存： 0x0000000102a59880  //存储了size对象的内存地址
类的堆空间——————————————————————
size指向内存的地址： 0x0000000102a59880 //被存储的内存地址
size指向内存变量的内容： 
0x0000000100010328  //这是个地址值，指向了这个变量的类型信息
0x0000000200000002  //引用计数，ios使用的ARC计数器
0x0000000000000001  //存储了1
0x0000000000000002  //存储了2
结构体—————————————————————————
Point变量的地址： 0x00007ffeefbff430  //虽然代码中point是后定义的，但是是先存入内存的
Point变量的地址： 0x0000000000000003 0x0000000000000004 //存储了3和4

• 由于使用MemoryLayout返回的是栈空间的大小，所以如果要看一个类所占的内存的话，可以调用malloc_size函数。
• mac和IOS平台的malloc函数分配的内存大小总是16的倍数。如果小于16，会自动补齐。
• 可以通过：class_getInstanceSize 获得类的对象至少需要多少内存。

func testInstanceSize(){
    class Point{
        var x = 11 // 8
        var test = true // 1
        var y = 22 //8
    }
    
    //实际使用了16 + 8 + 8 + 1 = 33 ->这是实际利用的
    
    var p = Point()
    print(class_getInstanceSize(Point.self)) // 40
    print(class_getInstanceSize(type(of: p))) // 40 -> 正常工作最小是40，32+1，其中1是8位的对齐参数
    print(Mems.size(ofRef: p))  //实际分配了48,通过malloc申请，最小段是16字节
}

四.值类型

1. 值类型赋值给let，var或者给函数传参，是直接将所有内容拷贝一份。
2. 产生了一个全新的副本文件，属于深拷贝（deep copy）
3. 改变值类型拷贝后的副本不会影响到原数据，因为是在副本的内存上修改的，和原数据无关。

func testValueType() {
    struct Point{
        var x : Int
        var y : Int
    }
    
    var p1 = Point(x: 10, y: 20)
    
    var p2 = p1
    p2.x = 11
    p2.y = 22
}

其中一段汇编：
初始化方法中将10赋值给rax，20赋值给rdx

rax == 10
rdx == 20

//rax和rdx放在了连续的16字节
movq   %rax, -0x10(%rbp)   //第一次将rax赋值给rbp -0x10 == 0x1000
//p1结构体变量x的内存地址
movq   %rdx, -0x8(%rbp)    //第一次将rdx赋值给rbp -0x8 == 0x1008
//p1结构体变量y的内存地址

movq   %rax, -0x20(%rbp)   //rbp -0x20
//p2结构体变量x的内存地址
movq   %rdx, -0x18(%rbp)   //rbp -0x18
//p2结构体变量y的内存地址

//之后将11和22赋值到p2的内存地址
movq   $0xb, -0x20(%rbp)
movq   $0x16, -0x18(%rbp)

4. 在汇编的栈中，如果一个地址是rbp - xxxx，则一般是一个局部变量。rbp这个值每次调用函数都可能不一样。每次调用都会有一次将rsp赋值给rbp，而rsp的地址是外层给的，是会变化的。
5. 在汇编的栈中，如果一个地址是rip + xxxx，则一般是一个全局变量。rip一般是固定的，就是下一条汇编指令的地址。
6. 全局变量在程序启动的时候，内存已经确定了。
7. 局部变量在每次调用函数的时候，内存都可能有所改变。
8. string，array，dic都是结构体，属于值类型。在swift标准库中用写时复制，只有在修改内存时，才会使用深复制操作，如果在编译中发现修改内存，则只会做浅复制。

五.引用类型

1. 引用赋值赋值给let，var或者给函数传参时，是将内存地址拷贝一份。
2. 副本与原数据指向同一个文件，属于浅拷贝。
3. 引用类型向堆空间申请地址后，堆空间返回的是对象的地址值。

六.寄存器一般用途

1. rax一般用作函数返回值。
2. rdi，rsi，rdx，rcx，r8，r9一般常用于放函数参数。
3. rsp，rbp用于栈操作，存储栈空间的地址值，也叫栈指针。
4. 如果参数过多，函数参数寄存器不够用，会将多余的参数放到与参数空间相邻的栈空间。就是如果rdi等不够，会放在rsp，rbp中。
5. 介于rbp和rsp之间一般是放函数的局部变量。
6. rip作为指令指针，存储了cpu下一条要执行的指令的地址，一旦cpu读取一条指令，rip会自动指向下一条指令。
7. rax + xxxx一般是堆空间
8. rbp - xxxx，则一般是一个局部变量
9. rip + xxxx，则一般是一个全局变量

七.引用类型和值类型的let

1. 一个值是常量，代表了这个值的内存是不可以更改的。
2. 值类型的常量内容在栈中，栈中的数据不会变化，所以不能更改。
3. 引用类型的常量的内容在堆中，栈中存放的是堆的地址，栈中的不变，但是堆中的内容可以被更改。

八.方法的内存

1. 方法的本质是函数，不占用类或者结构体的内存，方法和函数都是存放在代码段之中的。
2. IOS内存由上到下是代码段，数据段，堆空间，栈空间。