1. 获取内存大小的三种方式
sizeofclass_getInstanceSizemalloc_size
1.1 sizeof
-
sizeof是一个操作符，不是函数 - 一般使用时，传入的对象是
数据类型，这个在编译时决定 -
sizeof最终得到的结果是该数据类型占用空间的大小
1.2 class_getInstanceSize
-runtime提供的 api，用于获取类的实例对象所占用的内存大小
- 返回具体的字节数，其本质是获取实例对象中成员变量的内存大小
1.3 malloc_size
- 获取系统实际分配的内存大小
1.4 代码验证
可以通过代码进行验证：
#import
#import
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
NSObject *object = [[NSObject alloc] init];
NSLog(@"%lu",sizeof(object));
NSLog(@"%lu",class_getInstanceSize([object class]));
NSLog(@"%lu",malloc_size((__bridge const void *)(object)));
}
@end
输出结果：
2020-12-23 21:23:17.335020+0800 Test[3610:219003] 8
2020-12-23 21:23:17.335198+0800 Test[3610:219003] 8
2020-12-23 21:23:17.335440+0800 Test[3610:219003] 16
1.5 总结
- sizeof
计算类型占用内存大小，其中可以放基本数据类型、对象、指针
对于对象而言，打印的就是对象objc的指针大小，所以是8
对于指针而言，64 位下是 8 个字节
- class_getInstanceSize
计算对象实际占用的内存大小，这个跟类的属性相关，如果类中没有自定义属性，仅继承于
NSObject，则类的实例对象实际占用的内存大小是8
- malloc_size
计算系统为对象实际分配的内存，可以看出实际分配的和实际占用的并不相等
2. 结构体内存对齐
下面，我们首先定义两个结构体，分别计算他们的内存大小，以此来引入今天的整体：内存对齐原理。
//1、定义两个结构体
struct Mystruct1{
char a; //1字节
double b; //8字节
int c; //4字节
short d; //2字节
} Mystruct1;
struct Mystruct2{
double b; //8字节
int c; //4字节
short d; //2字节
char a; //1字节
} Mystruct2;
//计算 结构体占用的内存大小
NSLog(@"%lu-%lu",sizeof(Mystruct1),sizeof(Mystruct2));
下面是输出结果：
两个结构体只有成员变量的顺序有所区别，但是在输出结果中，他们所占用的内存大小却是不相等的，这就是内存对齐现象。
2.1 内存对齐规则
每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。在iOS中，Xcode默认为#pragma pack(8)，即8字节对齐。
一般内存对齐的原则主要有3点，可以回看iOS alloc & init 源码学习中的说明。
内存对齐规则可以这么理解：
【一】 数据成员的对齐规则可以理解为
min(m, n)的公式, 其中m表示当前成员的开始位置,n表示当前成员所需要的位数。如果满足条件m 整除 n（即 m % n == 0）,n从m位置开始存储, 反之继续检查m+1 能否整除 n, 直到可以整除, 从而就确定了当前成员的开始位置。
【二】数据成员为结构体：当结构体嵌套了结构体时，作为数据成员的结构体的自身长度作为外部结构体的最大成员的内存大小，比如结构体a嵌套结构体b，b中有char、int、double等，则b的自身长度为8
【三】最后结构体的内存大小必须是结构体中最大成员内存大小的整数倍，不足的需要补齐。
2.2 验证对齐规则
下表是各种数据类型在iOS中的占用内存大小,根据对应类型来计算结构体中内存大小:
我们可以通过下图图来说明下为什么两个结构体MyStruct1 & MyStruct2的内存大小打印不一致的情况，如图所示:
结构体 MyStruct1 内存大小计算过程：
-
变量 a：占1个字节，从0开始，此时min(0,1)，即0 存储 a -
变量b：占8个字节，从1开始，此时min（1，8），1不能整除8，继续往后移动，知道min（8，8），从8开始，即8-15 存储 b -
变量c：占4个字节，从16开始，此时min（16，4），16可以整除4，即16-19 存储 c -
变量d：占2个字节，从20开始，此时min(20, 2)，20可以整除2，即20-21 存储 d
因此MyStruct1的需要的内存大小为22字节，而MyStruct1中最大变量的字节数为8，所以MyStruct1 实际的内存大小必须是8 的整数倍，18向上取整到24，主要是因为24是8的整数倍，所以 sizeof(MyStruct1) 的结果是24。
结构体MyStruct2 内存大小计算：
-
变量b：占8个字节，从0开始，此时min（0，8），即0-7 存储 b
-变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即8-11 存储 c
-变量d：占2个字节，从12开始，此时min(12, 2)，12可以整除2，即12-13 存储 d
-变量a：占1个字节，从14开始，此时min（14，1），即14 存储 a
因此MyStruct2的需要的内存大小为 15字节，而MyStruct1中最大变量的字节数为8，所以MyStruct2 实际的内存大小必须是8 的整数倍，15向上取整到16，主要是因为16是8的整数倍，所以 sizeof(MyStruct2) 的结果是 16。
2.3 结构体嵌套结构体
我们再来验证一下结构体嵌套结构体的情况。
- 定义一个结构体
MyStruct3，在MyStruct3中嵌套MyStruct2，如下所示:
//1、结构体嵌套结构体
struct Mystruct3{
double b; //8字节
int c; //4字节
short d; //2字节
char a; //1字节
struct Mystruct2 str;
}Mystruct3;
//2、打印 Mystruct3 的内存大小
NSLog(@"Mystruct3内存大小：%lu", sizeof(Mystruct3));
NSLog(@"Mystruct3中结构体成员内存大小：%lu", sizeof(Mystruct3.str));
输出结果图：
2020-12-29 23:01:24.312834+0800 DebugTest[10600:575125] Mystruct3内存大小：32
2020-12-29 23:01:24.313016+0800 DebugTest[10600:575125] Mystruct3中结构体成员内存大小：16
分析Mystruct3的内存计算：
-
变量b：占8个字节，从0开始，此时min（0，8），即0-7 存储 b
-变量c：占4个字节，从8开始，此时min（8，4），8可以整除4，即8-11 存储 c
-变量d：占2个字节，从12开始，此时min(12, 2)，12可以整除2，即12-13 存储 d
-变量a：占1个字节，从14开始，此时min（14，1），即14 存储 a -
结构体成员str：str是一个结构体，根据内存对齐原则二，结构体成员要从其内部最大成员大小的整数倍开始存储，而MyStruct2中最大的成员大小为8，所以str要从8的整数倍开始，当前是从15开始，所以不符合要求，需要往后移动到16，16是8的整数倍，符合内存对齐原则，所以16-31 存储 str
因此MyStruct3的需要的内存大小为 32字节，而MyStruct3中最大变量为str, 其最大成员内存字节数为8，根据内存对齐原则，所以 MyStruct3 实际的内存大小必须是8的整数倍，32正好是8的整数倍，所以 sizeof(MyStruct3) 的结果是 32。
其内存存储情况如下图所示：
2.4 总结
MyStruct1通过内存字节对齐原则，增加了9个字节，而 MyStruct2通过内存字节对齐原则，通过 4 + 2 + 1的组合，只需要补齐一个字节即可满足字节对齐原则，所以：结构体内存大小与结构体成员内存大小的顺序有关。
- 如果是结构体中数据成员是根据内存从小到大的顺序定义的，根据内存对齐规则来计算结构体内存大小，需要增加有较大的内存padding即内存占位符，才能满足内存对齐规则，比较浪费内存。
- 如果是结构体中数据成员是根据内存从大到小的顺序定义的，根据内存对齐规则来计算结构体内存大小，我们只需要补齐少量内存padding即可满足堆存对齐规则。
3. 对对象属性重排的探究
自定义一个Person类：
@interface Person : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, copy) NSString *nickName;
@property (nonatomic, assign) int age;
@property (nonatomic, assign) long height;
@property (nonatomic) char c1;
@property (nonatomic) char c2;
@end
@implementation Person
@end
在main中创建Person的实例对象，并对其中的几个属性赋值:
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [Person alloc];
person.name = @"CJL";
person.nickName = @"C";
person.age = 18;
person.c1 = 'a';
person.c2 = 'b';
NSLog(@"%@",person);
}
return 0;
}
断点调试 Person，根据 Person 的对象地址，查找出属性的值：
-
通过地址找出name & nickName**
image.png -
通过地址找 age 等数据
通过0x0000001200006261地址找 age 等数据时，发现是乱码。这是因为苹果针对 age、c1、c2 属性的内存进行了重排，因为 int 类型占 4 个字节，char 类型占 1 个字节，通过 4+1+1 的方式，按照 8 字节对齐，存储在同一块内存中。
age 的读取通过0x00000012；
c1 的读取通过0x61，a 的 ASCII 码是 97
c2 的读取通过0x62，b 的 ASCII 码是 98
image.png -
最后来看下 person 对象 的内存分布情况：
image.png
注意：
int\char类型的数据读取出来是以 ASCII 码的形式显示
图片中地址为 0x0000000000000000，表示 person 中还有属性未赋值
- 总结：
大部分的内存都是通过固定的内存块进行读取；
尽管我们在内存中采用了内存对齐的方式，但并不是所有的内存都可以进行浪费的，苹果会自动对属性进行重排，以此来优化内存。
4. 字节对齐到底采用多少字节对齐？
到目前为止，我们在前文既提到了8字节对齐，也提及了16字节对齐，那我们到底采用哪种字节对齐呢？
- 对于对象来说，其真正的对齐方式是 8 字节对齐，8 字节对齐已经足够满足对象的需求了
- 苹果为了容错，采用的是16字节对齐的内存，主要是因为采用8字节对齐时，两个对象的内存会紧挨着，显得比较紧凑，而16字节比较宽松，利于苹果以后的扩展。
综合前文提及的获取内存大小的方式：
- class_getInstanceSize：是采用8字节对齐，参照的对象的属性内存大小
- malloc_size：采用16字节对齐，参照的整个对象的内存大小，对象实际分配的内存大小必须是16的整数倍。