获取内存大小的三种方式
获取内存大小的三种方式分别是：
- sizeof
- class_getInstanceSize
- malloc_size
sizeof
- 1、sizeof是一个操作符，不是函数
- 2、我们一般用sizeof计算内存大小时，传入的主要对象是数据类型，这个在编译器的编译阶段就会确定大小而不是在运行时确定。
- 3、sizeof最终得到的结果是该数据类型占用空间的大小
class_getInstanceSize
这个方法是runtime提供的api，用于获取类的实例对象所占用的内存大小，并返回具体的字节数，其本质就是获取实例对象中成员变量的内存大小。
malloc_size
这是一个函数，这个函数是获取系统实际分配的内存大小
可以通过下面代码的输出结果来验证我们上面的说法
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <malloc/malloc.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSObject *objc = [[NSObject alloc] init];
NSLog(@"objc对象类型占用的内存大小：%lu",sizeof(objc));
NSLog(@"objc对象实际占用的内存大小：%lu",class_getInstanceSize([objc class]));
NSLog(@"objc对象实际分配的内存大小：%lu",malloc_size((__bridge const void*)(objc)));
}
return 0;
}
以下是打印结果：
image2023-2-18_14-25-4.png
总结
- sizeof:计算类型占用的内存大小，其中可以放基本数据类型、对象、指针
- 对于类似于int这样的基本数据类型而言，sizeof获取的就是 数据类型占用的内存大小，不同的数据类型所占用的内存大小是不一样的。
- 而对于类似于 NSObject定义的实例对象而言，其对象类型的本质就是一个结构体（即 struct objc_object）的指针，所以sizeof(objc)打印的是对象objc的指针大小，我们知道一个指针的内存大小是8，所以打印的是8。（注意：这里的8字节与isa指针一点关系都没有！！！）
- 对于指针而言，sizeof打印的就是8，因为一个指针的内存大小是8.
- class_getInstanceSize:计算对象实际占用的内存大小，这个需要依据类的属性而变化，如果自定义类没有自定义属性，仅仅只是继承自NSObject，则类的实例对象实际占用的内存大小是8，简单可以理解为8字节对齐。
- malloc_size 计算对象实际分配的内存大小，这个是有系统完成的，可以从上面的打印结果看出，实际分配的和实际占用的内存大小并不相等。
结构体内存对齐
接下来，我们首先定义俩个结构体，分别计算他们的内存大小，以此来引入我们今天的正题：内存对齐原理
//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));
以下是输出结果：
image2023-2-18_14-37-34.png
从打印的结果我们可以看出一个问题，俩个结构体乍一看，没什么区别，其中定义的变量 和变量类型都是一致的，唯一的区别只是在于定义变量的顺序不一致，那为什么他们所占用的内存大小不相等呢？其实这就是iOS中的内存字节对齐现象。
内存对齐规则
每个特定的平台上的编译器都有自己默认的”对齐系数“（也叫对齐模数）。程序员可以通过预编命令 #pragma pack(n) 其中 n = 1,2,4,8,16来改变这一系数，其中的n就是你要指定的对齐系数。在iOS中，xcode默认为 #pragma pack(8),即8字节对齐。
一般内存对齐的原则主要有三点：
- 【原则一】数据成员的对齐规则可以理解为min(m,n)的公式，其中 m 表示当前成员的开始位置，n表示当前成员所需要的位数。如果满足条件 m 整除 n 即（m % n == 0），n 从m位置开始存储，反之继续检查 m+1 能否整除 n，知道可以整除，从而就确定了当前成员的开始位置。
- 【原则二】数据成员为结构体：当结构体嵌套了结构体时，作为数据成员的结构体的自身长度作为外部结构体的最大成员的内存大小，比如结构体a嵌套结构体b，b中有char、int、double等，则b的自身长度为8
- 【原则三】最后 结构体的内存大小 必须是结构体中最大成员内存大小的整数倍，不足的需要补齐。
验证对齐原则
下表是各种数据类型在iOS中的占用内存大小，根据对应类型来计算结构体中内存大小
image.png
我们可以通过下图来说明为什么俩个结构体 MyStruct1 & MyStruct2 的内存大小打印不一致的情况，如图所示
image2023-2-18_15-16-4.png
image2023-2-18_15-21-4.png
结构体MyStruct1内存大小计算：
根据内存对齐规则，计算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
因此MyStuct1 的需要内存大小为15个字节，而MyStuct1中 最大变量的字节数为8，所以MyStruct1实际的内存大小必须是8的整数倍，18向上取整到24，主要是因为24是8的倍数，所以sizeof(MyStruct1)的结果为24。
结构体MyStruct2内存大小计算：
根据内存对齐规则，计算MyStruct12的内存大小，详解过程如下：
- 变量b：占8个字节，从0开始，此时 min(0,7),即 0-7存储a
- 变量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可以整除1，即14存储a
因此MyStruct2的需要内存大小为15个字节，而MyStruct2中最大变量的字节数为8，所以 MyStruct2 实际的内存大小必须是 8 的整数倍，15向上取整到16，主要是因为16是8的整数倍，所以 sizeof(MyStruct2) 的结果是 16
结构体嵌套结构体
上面的俩个结构体只是简单的定义数据成员，下面来一个比较复杂的，结构体中嵌套结构体的内存大小计算情况
首先定义一个结构体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));
image2023-2-18_15-41-48.png
分析MyStruct3的内存情况：
根据内存对齐规则，来一步一步分析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)，20可以整除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
其内存存储情况如下图所示
image2023-2-18_15-51-43.png
二次验证
为了保险起见，我们再定义一个结构体，来验证我们结构体嵌套的内存大小计算说明
struct Mystruct4{
int a; //4字节 min（0，4）--- （0，1，2，3）
struct Mystruct5{ //从4开始，存储开始位置必须是最大的整数倍（最大成员为8），min（4，8）不符合 4，5，6，7，8 -- min（8，8）满足，从8开始存储
double b; //8字节 min(8,8) --- (8,9,10,11,12,13,14,15)
short c; //1字节,从16开始，min（16，1） -- （16，17）
}Mystruct5;
}Mystruct4;
NSLog(@"Mystruct4内存大小：%lu - %lu",sizeof(Mystruct4),sizeof(Mystruct4.Mystruct5));
分析如下
- 变量a：占4字节，从0开始，min（0，4），即 0-3存储a
- 结构体Mystruct5：从4开始，根据内存对齐原则二，即存储开始位置必须是最大的整数倍（最大成员为8），min（4，8）不能整除，继续往后移动，直到8， min（8，8）满足，从8开始存储结构体Mystruct5的变量
- 变量b：占8字节，从8开始，min（8，8），可以整除，即 8-15存储b
- 变量c：占2字节，从16开始，min（16，2），可以整除，即16-17存储c
因此Mystruct4中需要的内存大小是 18字节，根据内存对其原则二，Mystruct4实际的内存大小必须是Mystruct5中最大成员b的整数倍，即必须是8的整数倍，所以sizeof(Mystruct4) 的结果是 24
以下是运行结果的打印，以此来印证24这个内存大小
image2023-2-18_15-58-15.png
内存优化（属性重排）
- 如果是结构体中数据成员是根据内存从小到大的顺序定义的，根据内存对齐规则来计算结构体内存大小，需要增加有较大的内存padding即内存占位符，才能满足内存对齐规则，比较浪费内存
- 如果是结构体中数据成员是根据内存从大到小的顺序定义的，根据内存对齐规则来计算结构体内存大小，我们只需要补齐少量内存padding即可满足堆存对齐规则，这种方式就是苹果中采用的，利用空间换时间，将类中的属性进行重排，来达到优化内存的目的
以下面这个例子来进行说明 苹果中属性重排，即内存优化
- 定义一个自定义LXHPerson类，并定义几个属性
@interface LXHPerson : 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 LXHPerson
@end
-
在main中创建LXHPerson的实例对象，并对其中的几个属性赋值
image2023-2-18_16-27-34.png
断点调试person，根据LXHPerson的对象地址，查找出属性的值
-
通过地址找出 name & nickName
image2023-2-18_16-28-58.png
- 当我们向通过0x0000001200006261地址找出age等数据时，发现是乱码，这里无法找出值的原因是苹果中针对age、c1、c2属性的内存进行了重排，因为age类型占4个字节，c1和c2类型char分别占1个字节，通过4+1+1的方式，按照8字节对齐，不足补齐的方式存储在同一块内存中，
- age的读取通过0x00000012
- c1的读取通过0x61（a的ASCII码是97）
-
c2的读取通过0x62（b的ASCII码是98）
image2023-2-18_16-25-23.png
注意：
1、char类型的数据读取出来是以ASCII码的形式显示
2、图片中地址为0x0000000000000000,表示person中还有属性未赋值
所以，这里可以总结下苹果中的内存对齐思想： - 大部分的内存都是通过固定的内存块进行读取，
- 尽管我们在内存中采用了内存对齐的方式，但并不是所有的内存都可以进行浪费的，苹果会自动对属性进行重排，以此来优化内存。
网友评论