内存对齐

C和Objective-C 各数据类型在不同的系统中所占的内存大小

C	OC(Objective-C)	32位	64位
bool	BOOL(64位)	1	1
signed char	(__signed char)int8_t、BOOL(32位)	1	1
unsigned char	Boolean	1	1
short	int16_t	2	2
unsigned char	unichar	2	2
int、int32_t	NSInteger(32位)、boolean_t(32位)	4	4
unsigned int	NSUInteger(32位)、boolean_t(64位)	4	4
long	NSInteger(64位)	4	8
unsigned long	NSUInteger(64位)	4	8
long long	int64_t	8	8
float	CGFloat(32位)	4	4
double	CGFloat(64位)	8	8

获取内存大小的方式

获取内存大小的方式：

1. size_of
   • size_of是一个操作符，不是函数，我们使用size_of计算内存大小的时候，传入的主要对象是数据类型，这个在编译器的编译阶段(即编译时)就会确定大小而不是在运行时确定。
   • size_of的计算结果是该数据类型所占用的空间大小。
2. class_getInstanceSize
   • runtime提供的API，用于获取类的实例对象所占用的内存大小，并返回具体的字节数，其本质就是获取实例对象中成员变量所占的内存大小。
3. malloc_size
   • 这个函数是获取系统实际分配的内存大小。

我们来看下面这段代码的执行结果

#import <UIKit/UIKit.h>
#import "AppDelegate.h"
#import <objc/runtime.h>
#import <malloc/malloc.h>
#import "Person.h"


int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        Person *person = [Person alloc];
        
        NSLog(@"person 所占的内存大小%lu", sizeof(person));
        NSLog(@"[person class] 实际所占的内存大小%ld", class_getInstanceSize([person class]));
        NSLog(@"person 实际开辟的内存大小%ld", malloc_size((__bridge const void*)(person)));
        appDelegateClassName = NSStringFromClass([AppDelegate class]);
        
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

执行结果.png

Person中的属性

@interface Person : NSObject
@property (nonatomic) char c;
@property (nonatomic) char d;
@property (nonatomic, assign) BOOL isGay;
@property (nonatomic, copy) NSString *name;
@end

内存中的占用情况

实例化的person内存占用情况.png

总结

1. sizeof
   • 计算类型占用空间大小，可以传基本数据类型，实例化对象，指针
   • 不难解释这里传入的person，为什么会输出8。这里的sizeof(person)其实打印的是指向Person在内存中的地址的指针大小，指针都是8字节。
2. class_getInstanceSize
   • 计算的是类实际占用的内存大小，跟对象的属性有关，采用8字节对齐算法
   • 结合person的内存占用情况，与8字节对齐算法，不难得出，Apple在8字节对齐对齐的前提下，也采用了内存优化和重排。char，BOOL，在系统中都占用1字节，如果只按照8字节对齐算法，肯定会造成空间浪费，所以这里属性c、d、isGay被排列到了一起，共用8个字节，加上name(NSString对象)属性的8字节，和isa0x000000010af47728，所以实际占用的内存大小为24。
3. malloc_size
   • 计算实际开辟的内存大小，采用16字节对齐算法，结合class_getInstanceSize，所以最终开辟的内存为32，24不符合16字节对齐，可以去掉name属性，此时class_getInstanceSize和malloc_size得到的内存大小就是一致的了。

结构体内存对齐

我们先来看下面这个例子

struct StructOne {
    char    b;//1字节
    double  d;//8字节
    int     a;//4字节
    short   c;//2字节
}StructOne;

struct StructTwo {
    int     a;
    char    b;
    short   c;
    double  d;
}StructTwo;

NSLog(@"%lu-%lu",sizeof(StructOne),sizeof(StructTwo));

//输出结果
24-16

为什么两个组成元素完全相同的结构体，所占的内存大小却不一样呢？唯一不同的地方就是他们的排序。排序会影响结构体的内存大小么？

结构体内存对齐原则

1. 当前成员的起始位置，能整除当前成员所需的内存大小，则开始存，如果不满足，则向后移动至第一个能整除当前成员所需内存大小的位置开始存。
2. 当结构体A内部成员有结构体B时，计算结构B起始位置的内存大小，由结构体B内部最大成员的来决定。如：结构体B中有char,short,double，则结构体B在结构体A中计算起始位置的内存由double来决定，也就是为必须为8的倍数，在结构体A中所需要的实际长度还是为结构体B的实际长度。
3. 结构体的最终大小，必须是内部最大成员的整数倍。

有了对齐原则，再分析上面的案例就容易多了。
StructTwo：
int a, 4字节，起始位置为0，直接存，使用[0,3]空间；
char b,1字节，起始位置为4，直接存，使用编号4的空间；
short c, 2字节，起始位置为5，不能被2整除，右移一位，使用[6,7]空间；
double d, 8字节，起始位置为8，直接存，使用[8,15]
总长度16，为double b的倍数，故长度为16
StructOne：
char b,1字节，起始位置为0，直接存，使用编号0的空间；
double d, 8字节，起始位置为1，右移7位，使用[8,15]
int a, 4字节，起始位置为16，直接存，使用[16,19]空间；
short c, 2字节，起始位置为20，直接存，使用[21,22]空间；
总长度不为double b的倍数，补两位，长度为24

• 图解

  
  image.png

继续论证结构体中包含结构体的情况

struct StructOne {
    char    b;
    int     a;
}StructOne;

struct StructTwo {
    char    b;
    struct StructOne structOne;
    int     a;
    short   c;
    double  d;
}StructTwo;

NSLog(@"%lu-%lu",sizeof(StructOne),sizeof(StructTwo));
//输出结果
8-32

分析
StructOne：
char b,1字节，起始位置为0，直接存，使用编号0的空间；
int a, 4字节，起始位置为1，右移3位，使用[4,7]空间；
总长度8，为int a的倍数，最终长度8
StructTwo:
char b,1字节，起始位置为0，直接存，使用编号0的空间；
struct StructOne structOne, 8字节，内部最大成员所需内存为4，其实位置为1，右移3位，使用[4,11]空间。
int a, 4字节，起始位置为12，直接存，使用[12,15]空间；
short c, 2字节，起始位置为16，直接存，使用[16,17]空间；
double d, 8字节，起始位置为18，右移6位，使用[24,31]空间；
总长度位32，为最大成员double d的倍数，最终长度为32

---