内存对齐原则

内存在使用过程并不是单一的依次排列，而是按照某种既定的规则来进行对齐，以方便快速访问.内存的对齐原则有以下三条：

• 数据成员对齐：成员根据其自身大小，从自身大小的整数倍内存地址(以第一个元素存储在0位置为参考)开始存储；
• 结构体成员对齐：如果包含了结构体成员，则结构体成员的存储位置从其内部成员最大值的整数倍地址开始存储；
• 结构体总大小对齐：必须要是其内部最大成员的整数倍，不足的要补齐.

注：以下内容在arm64指令集设备做演示.

数据成员对齐

在存储过程中，第一个成员变量会默认从相对位置为offset=0处开始存储，下一个成员的存储，要存储在其类型所需内存的整数倍地址位置处.

struct One{
    char a; //由于是第一个成员，且char类型需要一个字节存储数据，所以成员a存储在[0]处，占据一个字节；
    int b; //由于int类型需要四个字节存储数据，所以存储位置需要是4的整数倍，所以需要存储在[4]处，占据四个字节，也就是说成员b的存储占据了4-7四个字节的内存空间，所以a,b共占用了八个字节
}

使用Xcode初始化一个One类型的结构体变量：

One one = {'a', 12};

使用以下指令查看内存分布：

(lldb) po &one
0x000000016b31d3b8

(lldb) x/2wx 0x000000016b31d3b8
0x16b31d3b8: 0x00000061 0x0000000c //0x00000061=97存储成员'a', 0x0000000c=12存储成员b

可以看到由于数据成员对齐原则的影响，成员变量b从第五个字节开始存储，所以虽然第一个成员变量a只需要一个字节的存储空间，但为了字节对齐，之后的三个字节空间是空出来的,也可以理解为内存使用了四个字节来存储成员变量a.

结构体成员对齐

如果包含了结构体成员，则结构体成员的存储位置从其内部成员最大值的整数倍地址开始存储.

struct Two {
    short c; //2个字节，存储起始地址0开始，占用两个字节
    One d; //由于结构体One中的成员变量有两个类型的成员变量char(1个字节),int(4个字节)，所以One需要从4处开始存储，占据5个字节,所以c，d共占用了9个字节
};

初始化一个Two类型的结构体变量：

    One one = {'a', 12};
    Two two = {
        20,
        one
    };

使用一下指令查看内存分布:

(lldb) po &two
0x000000016d3953a8

(lldb) x/4wx 0x000000016d3953a8
0x16d3953a8: 0x9f750014 0x0000000c 0x00000061 0x00000000

可以看到由于结构体One中最大的成员变量是int类型(4字节),所以成员变量d在内存中从第四个字节的位置开始存储，占据八个字节.

结构体总大小对齐

结构体总体占据内存的大小必须要是其内部最大成员的整数倍，不足的要补齐.所以，在结构体Three中

struct Three {
    int e;//从0处开始存储，占据4个字节
    char f; //根据[数据成员对齐]规则,从5处开始存储占据一个字节
}

初始化一个Three类型的结构体变量：

Three three = {12, 'a'};

根据数据成员对齐和结构体成员对齐原则，结构体变量three需要5个字节进行存储，但是根据结构体总大小对齐原则，结构体变量three需要补齐三个字节以满足结构体大小为(int 占据4个字节)的整数倍.所以该结构体变量需要八个字节空间进行存储.

根据以上原则，以下结构体占据的字节空间为：

struct Four
{
     int id;             //[0]....[3]
     double weight;      //[8].....[15]　　　　　　数据成员对齐原则
     float height;      //[16]..[19],总长要为８的整数倍,补齐[20]...[23]　　　　　结构体总大小对齐原则
};

所以Four结构体变量的存储需要24个字节




struct Five {
    int a;
}

struct Six {
    char c; //[0]
    Five d; //[4]...[7]     成员变量对齐原则
    char e; //[8],总长为4的倍数，需要补齐[9],[10], [11]        结构体总大小对齐原则
};

所以Six类型的成员变量的存储需要12个字节



typedef Seven {
    int a;  //[0]-[3]
    short b[2]; // [4]-[7]          成员变量对齐原则
                //需要补齐最后一位     结构体总大大小对齐原则
}seven;

所以Seven类型的成员变量的存储需要8个字节


typedef struct {
    int a; //[0]--[3]
    char b[3]; //[4],[5],[6]     成员变量对齐原则
    Seven c; //[8]-[15]          成员变量对齐原则
             //需要补齐最后一位    结构体总大大小对齐原则
}Eight;

所以Eight类型的成员变量的存储需要16个字节

而结构体在很大程度上其实是类的原型，所以类的内存分布与结构体相似的，只不过在OC的类中，默认有一个isa的存在，所以第一个成员变量都是isa.

@interface EWPerson : NSObject
//隐藏的成员变量isa                            8个字节
@property (copy, nonatomic) NSString *name;  //8个字节
@property (assign, nonatomic) NSInteger age; //8个字节
@property (assign, nonatomic) NSInteger height; //8个字节

@end

@implementation EWPerson

@end

所以EWPerson类型的对象需要32个字节,其中：

• isa:8个字节；
• name：8个字节;
• age：8个字节；
• height：8个字节；

初始化一个EWPerson类型的对象：

    EWPerson *person = [[EWPerson alloc] init];
    person.age = 12;
    person.name = [NSString stringWithFormat:@"%@", @"abcd"];
    person.height = 175;

使用LLDB查看一下内存分布：

(lldb) po person
<EWPerson: 0x280bd2aa0>

(lldb) x/4gx 0x280bd2aa0
0x280bd2aa0: 0x000001a1028a94c5 0xfd97df07a4b040aa
0x280bd2ab0: 0x000000000000000c 0x00000000000000af

跟预期一样，其中name对应的0xfd97df07a4b040aa是一个tagged pointer指针.

如果将将age修改为int类型，而height修改为double类型,根据成员变量对齐原则，height需要从相对位置[24]开始存储，所以age虽然需要四个字节，但是紧随其后的四个字节需要填充0来对齐：

@interface EWPerson : NSObject
//隐藏的成员变量isa                            8个字节
@property (copy, nonatomic) NSString *name; //8个字节(可能是真实的地址指针，也可以是tagged pointer类型指针)
@property (assign, nonatomic) int age;      //4个字节
@property (assign, nonatomic) double height; //8个字节

@end

@implementation EWPerson

@end

初始化一个EWPerson类型的对象：

    EWPerson *person = [[EWPerson alloc] init];
    person.age = 12;
    person.name = [NSString stringWithFormat:@"%@", @"abcd"];
    person.height = 175;

使用LLDB查看内存分布：

(lldb) po person
<EWPerson: 0x2809192a0>

(lldb) x/4gx 0x2809192a0
0x2809192a0: 0x000001a10099d4c5 0x000000000000000c
0x2809192b0: 0xf4b9afbebc95968e 0x4065e00000000000

发现：

• 本来应该在第二个位置的那么属性跑到了第三个位置，而本来在第三个位置的age跑到了第二个位置

这是为啥呢？其实也很好理解，这是编译器做了优化，将成员变量按照所需要字节的大小依次排列，这样小的字节就有可能会组合在一起构成一个构成一个大的成员变量所需要的字节，从而达到节约内存的目的.

例如：

struct Nine {
    short a; //2个字节,[0]-[1]
    int b; //4个字节,根据成员变量对齐原则,需要从[4]开始存储,即存储占据[4]-[7]四个字节
    short c; //2个字节,[8]-[9]
}
最终，根据整体大小对齐原则，结尾需要补齐2个字节该结构体的实例需要12个字节来进行存储.然后同样的的成员变量，进行位置优化之后：

struct Nine {
    short a; //2个字节,[0]-[1]
    short c; //2个字节,[2]-[3]
    int b; //4个字节,根据成员变量对齐原则,需要从[4]开始存储,即存储占据[4]-[7]四个字节
}
此时只需要8个字节就可以存储该结构的实例.

也可以通过clang命令进行重写：

xcrun -sdk iphonesimulator clang -rewrite-objc main.m

在新生成的.cpp文件中查找到类对应的结构体：

#ifndef _REWRITER_typedef_EWPerson
#define _REWRITER_typedef_EWPerson
typedef struct objc_object EWPerson;
typedef struct {} _objc_exc_EWPerson;
#endif

extern "C" unsigned long OBJC_IVAR_$_EWPerson$_name;
extern "C" unsigned long OBJC_IVAR_$_EWPerson$_age;
extern "C" unsigned long OBJC_IVAR_$_EWPerson$_height;
struct EWPerson_IMPL {
	struct NSObject_IMPL NSObject_IVARS;
	int _age;
	NSString * _Nonnull _name;
	double _height;
};

可见，编译器确实对类对应的结构体进行了优化，主要的目的就是合理利用空间，节约内存.主要的方法就是将成员变量按照所需字节空间大小生序排列，尽可能将小的字节空间组合成单位字长进行存储.

• 第三个位置的tagged pointer和之前的值不一样

这很正常，每次的结果都有可能不一致，因为这个结果是真实值异或了一个随机数(objc_debug_taggedpointer_obfuscator)得到的，所以每次启动产生的随机数不一样，就会导致该结果不一致.详情可以查看tagged pointer.

• 最后一个值(0x4065e00000000000)是啥?

根据分析当然是成员变量height啦！因为在64bit操作系统中，double类型占据八个字节，其中符号位1位，指数位11位，尾数部分52位(参考浮点数在内存中的存储).

0x4065e00000000000 = 0b0100000001100101111000000000000000000000000000000000000000000000
其中：
最高位符号位：0，即表示正数；
接下来的11位表示指数位：0b10000000110减去1023(2^10-1)=0b00000000111=7
接下里的52位位位数：0b0101111000000000000000000000000000000000000000000000
所以表示的双精度浮点数为：
0b1.0101111000000000000000000000000000000000000000000000 * 2^7
=0b1.0101111 * 2^7
=0b10101111
=175