0x00 前言

前两天有人问到一个问题，当一个类中有四个成员变量，分别为int bool int bool时，系统是如何优化的。我一时没答上来。
本文会先给出答案，然后再说明如何得出这个答案，最后说明为什么这么做。

0x01 答案

系统会将占用内存小的成员变量放在前面，大的放在后面，再按照内存对齐原则进行布局。

0x02 过程

我们知道，类的成员变量都是存放在类对象的class_data_bits_t -> class_rw_t -> class_ro_t -> ivars中的。因此，当我们想要知道某一个类中成员变量有哪些，是如何排序的，只需要打印这个列表即可。

类对象底层结构

下面我创建了Person类，然后打印了他的成员变量列表如下。

@interface Person : NSObject
@property (nonatomic, assign) int a;
@property (nonatomic, assign) BOOL b;
@property (nonatomic, assign) int c;
@property (nonatomic, assign) BOOL d;
@end

ivar name：_b encode：B 偏移量：8
ivar name：_d encode：B 偏移量：9
ivar name：_a encode：i 偏移量：12
ivar name：_c encode：i 偏移量：16

可以发现成员变量并没有按照我们定义的属性顺序进行排序。两个bool类型的成员变量放在了最前面，两个int类型的放在了后面。

这并不是一个偶然，我们可以尝试换成其他类型的成员变量：

@interface Person : NSObject
@property (nonatomic, assign) double a;
@property (nonatomic, assign) BOOL b;
@property (nonatomic, assign) int c;
@property (nonatomic, assign) BOOL d;
@end

ivar name：_b encode：B 偏移量：8
ivar name：_d encode：B 偏移量：9
ivar name：_c encode：i 偏移量：12
ivar name：_a encode：d 偏移量：16

还是可以发现，两个bool类型的变量放在了最前面，接下去是int，最后才是double类型（占8字节）的。

可以发现一个规律，系统会给成员变量的排序进行优化，将占用内存小的放在前面，占用大的放在后面。那么系统为什么要进行这样的优化呢？

0x03 原因

为了尽可能的节约对象的内存占用。
这话怎么说呢？为什么这么排布就能节省对象的内存占用了呢？

还是以Person为例，当我们 Person *p = [[Person alloc] init];初始化一个对象时，会在堆里创建一个对象，这个对象本质上是一个结构体，p指针会指向这个结构体。对象的结构大致如下：

// 优化过的：
struct Person_obj {
    Class *isa;
    BOOL _b;
    BOOL _d;
    int _a;
    int _c;
};

// 没有优化过的：
struct Person_obj {
    Class *isa;
    int _a;
    BOOL _b;
    int _c;
    BOOL _d;
};

接下来，我们来打印下这两种结构体分别占用了多少内存。

typedef struct {
    Class *isa;
    BOOL _b;
    BOOL _d;
    int _a;
    int _c;
}Person_Objc_1;

typedef struct {
    Class *isa;
    int _a;
    BOOL _b;
    int _c;
    BOOL _d;
}Person_Objc_2;

NSLog(@"Person_Objc_1 ==== %lu", sizeof(Person_Objc_1));
NSLog(@"Person_Objc_2 ==== %lu", sizeof(Person_Objc_2));

// 输出
Person_Objc_1 ==== 24
Person_Objc_2 ==== 24

诶？这不是一样大吗，难道没有区别？
其实不是的，这里是因为内存对齐导致的，具体原因晚点再说。我们可以先把isa指针去掉，再打印一次。

typedef struct {
    BOOL _b;
    BOOL _d;
    int _a;
    int _c;
}Person_Objc_1;

typedef struct {
    int _a;
    BOOL _b;
    int _c;
    BOOL _d;
}Person_Objc_2;

NSLog(@"Person_Objc_1 ==== %lu", sizeof(Person_Objc_1));
NSLog(@"Person_Objc_2 ==== %lu", sizeof(Person_Objc_2));

// 输出
Person_Objc_1 ==== 12
Person_Objc_2 ==== 16

嗯，这次有区别了。的确，进行优化后的结构体所占用的内存比较小。
现在我们已经知道了系统如何优化，并且清楚了优化后的效果。那么，现在还有两个问题：

为什么优化后占用内存会变小？
为什么上面例子中有isa指针时看不出效果呢？

0x04 内存对齐

其实，上面两个问题都是由于同一个原因导致的：内存对齐。
内存对齐的原则：

1. 结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如说是数组，结构体等）的整数倍开始(比如int在３２位机为４字节,则要从４的整数倍地址开始存储。
1. 如果一个结构里有某些结构体成员,则结构体成员要从其内部最大元素大小的整数倍地址开始存储.(struct a里存有struct b,b里有char,int ,double等元素,那b应该从8的整数倍开始存储.)
1. 结构体的总大小,也就是sizeof的结果,.必须是其内部最大成员的整数倍.不足的要补齐.

相信你和我一样，看完这些仍然是一头雾水。下面我们来看下例子，下面是没有isa指针的时候的内存布局：

typedef struct {
    BOOL _b;   // 0-1
    BOOL _d;   // 1-2
    int _a;  // 4-8
    int _c;  // 8-12
}Person_Objc_1;
// 因为原则1，_a需要从它的大小的整数倍开始存储。
// 因此_a的位置是4-8而不是2-6，2-4这一段其实是空的。
// 同时因为原则3，整体的大小是最大成员的整数倍。
// 这里正好是12，因此已经满足原则3。

typedef struct {
    int _a;  // 0-4
    BOOL _b;  // 4-5
    int _c;  // 8-12
    BOOL _d;  // 12-13
}Person_Objc_2;

// 因为原则1，_c需要从它的大小的整数倍开始存储。
// 因此_c的位置是8-12而不是5-9，5-8这一段其实是空的。
// 同时因为原则3，整体的大小是最大成员的整数倍。
// 这里是13，不满足原则3，因此需要凑16，所以13-16是空的。

接下去我们再看下有isa时候的布局：

typedef struct {
    Class *isa;  // 0-8
    BOOL _b;  // 8-9
    BOOL _d;  // 9-10
    int _a;  // 12-16
    int _c;  // 16-20
}Person_Objc_1;

typedef struct {
    Class *isa;  // 0-8
    int _a;  // 8-12
    BOOL _b;  // 12-13
    int _c;  // 16-20
    BOOL _d;  // 20-21
}Person_Objc_2;

// 具体分析就免了，最终因为原则3导致总占用内存为8的倍数，导致两个都是24字节。

0x05 总结

当我们给类添加成员变量时，系统会给成员变量的布局进行优化，将占用字节小的放在前面，大的放在后面，同时遵循内存对齐原则进行布局，以实现对象占用内存最小的效果。

iOS基础：类的成员变量的内存优化