一、代码 Demo
struct Struct1 {
char a; // 1 字节
double b; // 8 字节
int c; // 4 字节
short d; // 2 字节
} MyStruct1;
struct Struct2 {
double b; // 8 字节
char a; // 1 字节
int c; // 4 字节
short d; // 2 字节
} MyStruct2;
struct Struct3 {
double b; // 8 字节
char a; // 1 字节
short d; // 2 字节
int c; // 4 字节
} MyStruct3;
struct Struct4 {
double b; // 8 字节
char a; // 1 字节
short d; // 2 字节
struct Struct3 c; // 16 字节
} MyStruct4;
- (void)demo
{
NSLog(@"%zd %zd", sizeof(MyStruct1), sizeof(MyStruct2));
NSLog(@"%zd %zd", sizeof(MyStruct3), sizeof(MyStruct4));
}
24 24
16 32
可以看到 Struct1、Struct2、Struct3 的成员变量的数据类型都是相同的，仅仅调整了变量定义的顺序，内存占用大小就发生了变化。
二、内存对齐规则
2.1 对齐系数
对齐系数，也叫对齐模数。
每个特定平台上的编译器都有默认的对齐系数。程序员可以通过预编译命令 #pragma pack(n)，n = 1, 2, 4, 8, 16 来改变这一系数，其中的 n 就是“对齐系数”。
#pragma pack(1)
struct Struct1 {
char a; // 1 字节
double b; // 8 字节
int c; // 4 字节
short d; // 2 字节
} MyStruct1;
struct Struct3 {
double b; // 8 字节
char a; // 1 字节
short d; // 2 字节
int c; // 4 字节
} MyStruct3;
- (void)demo
{
NSLog(@"%zd %zd", sizeof(MyStruct1), sizeof(MyStruct3));
}
15 15
仅修改了对齐系数，输出结果从 24 16 变成了 15 15。
苹果默认的对齐系数为
8。
2.2 对齐规则
struct 或 union 的内存对齐的规则：
-
数据成员普通数据类型
第一个数据成员放在偏移为 0 的地方，以后每个数据成员 M 的偏移为对齐系数 n 与 M 自身长度中较小那个数的整数倍，不够整数倍的补齐。
struct Struct1 { char a; // 1 字节 double b; // 8 字节 int c; // 4 字节 } MyStruct1;- a 的地址为 [0]，内存共占用 1 个字节；
- b 的地址为 MIN(n, 自身长度) = MIN(8, 8) = 8，b 的地址为 8*x，在这里 x 取 1 即可，所以 b 的地址为 [8]，补齐 a 后面 [1] ~ [7] 的空间，内存共占用 16 个字节；
- c 的地址为 MIN(n, 自身长度) = MIN(8, 4) = 4，所以 c 的地址为 4*x，在 a，b 放置之后，内存已经占用了 8 + 8 = 16 个，此时下一个地址正好是 4 的整数倍，所以 c 的地址为 [16]，内存共占用 20 个字节。
-
数据成员为 struct 或 union 类型
struct 或 union 的数据成员还是 struct 或者 union 类型，则该数据成员 M 的“自身长度”为其内部最大元素的大小。
struct Struct3 { double b; // 8 字节 char a; // 1 字节 short d; // 2 字节 int c; // 4 字节 } MyStruct3; struct Struct4 { double b; // 8 字节 char a; // 1 字节 short d; // 2 字节 struct Struct3 c; // 16 字节 } MyStruct4; 16 32根据这个规则，c 中含有 double、char、short、int 数据类型，它的自身长度就为 double(8)，MIN(n, 自身长度) = MIN(8, 8) = 8，c 的地址偏移值为 8*x，前面的 b、a、d 已经占了 12 个字节，所以 x = 2，需要填充 4 个字节，最终 MyStruct4 共需要占 32 个字节。
-
struct 或 union 的整体对齐
在内部数据成员按照上述第一步完成各自对齐之后，结构体本身也要进行对齐。
将结构体的大小调整为对齐系数 n 与结构体中的最大长度的数据成员中较小那个的整数倍，不够的补齐。
struct Struct1 { char a; // 1 字节 double b; // 8 字节 int c; // 4 字节 short d; // 2 字节 } MyStruct1;对齐系数 n = 8，结构体中最大长度的数据成员类型为 double，最大成员长度 = 8，MIN(8, 8) = 8，原本已占用内存大小为 8+8+4+2 = 22，最接近的 8 的倍数值是 24，所以补齐 2 个字节，最终共占用 24 个字节。
补齐之后：
struct Struct1 { char a; // 1 字节 char _pad0[7]; // 填充 7 字节 double b; // 8 字节 int c; // 4 字节 short d; // 2 字节 char _pad1[2]; // 填充 2 字节，让结构体的大小成为最大成员大小 double（8字节）的倍数 }
2.3 验证
使用如下代码打印结构体：
struct Struct1 {
char a; // 1 字节
double b; // 8 字节
int c; // 4 字节
short d; // 2 字节
} MyStruct1;
- (void)demo
{
NSLog(@"%zd", sizeof(MyStruct1));
NSLog(@"%ld, %ld, %ld, %ld", (long)&MyStruct1.a, (long)&MyStruct1.b, (long)&MyStruct1.c, (long)&MyStruct1.d);
}
24
4442808120, 4442808128, 4442808136, 4442808140
-
char a的地址是 20，下一个内存地址为 20 + 1； -
double b的地址是 28，从 21 直接跳到了 28，之间的为填充字节，下一个内存地址为 28 + 8； -
int c的地址是 36，c 与 b 之间没有填充字节，下一个内存地址为 36 + 4； -
short d的地址是 40，d 与 c 之间没有填充字节，下一个内存地址为 40 + 2; - 此时共占用 40 + 2 - 20 = 22 个字节，而打印出来 MyStruct1 占了 24 个字节，所以最后执行了 struct 的整体对齐，在末尾填充了两个字节。
三、为什么要进行内存对齐
编译器会为程序中的每个数据单元安排在适当的位置上，这个过程对于大部分程序员来说是透明的。内存对齐是由编译器处理。
要想掌控这项技术，在了解内存对齐的规则后，还应该知道编译器为什么会进行内存对齐。
很多 CPU（如基于 Alpha，IA-64，MIPS，和 SuperH 体系的）拒绝读取未对齐数据。当一个程序要求这些 CPU 读取未对齐数据时，这时 CPU 会进入异常处理状态并且通知程序不能继续执行。举个例子，在 ARM，MIPS，和 SH 硬件平台上，当操作系统被要求存取一个未对齐数据时会默认给应用程序抛出硬件异常。所以，如果编译器不进行内存对齐，那在很多平台的上的开发将难以进行。
那么，为什么这些 CPU 会拒绝读取未对齐数据？是因为未对齐的数据，会大大降低 CPU 的性能。
四、CPU 存取原理
程序员通常认为内存印象，由一个个的字节组成。
但是，你的 CPU 并不是以字节为单位存取数据的。CPU 把内存当成是一块一块的，块的大小可以是 2，4，8，16 字节大小，因此 CPU 在读取内存时是一块一块进行读取的。每次内存存取都会产生一个固定的开销，减少内存存取次数将提升程序的性能。所以 CPU 一般会以 2/4/8/16/32 字节为单位来进行存取操作。我们将上述这些存取单位也就是块大小称为（memory access granularity）内存存取粒度。
为了说明内存对齐背后的原理，我们通过一个例子来说明，从未地址与对齐地址读取数据的差异。
这个例子很简单：在一个存取粒度为 4 字节的内存中，先从地址 0 读取 4 个字节到寄存器，然后从地址 1 读取 4 个字节到寄存器。
当从地址 0 开始读取数据时，是读取对齐地址的数据，直接通过一次读取就能完成。当从地址 1 读取数据时，读取的是非对齐地址的数据。需要读取两次数据才能完成。
而且在读取完两次数据后，还要将 0-3 的数据向上偏移 1 字节，将 4-7 的数据向下偏移 3 字节。最后再将两块数据合并放入寄存器。
对一个内存未对齐的数据进行了这么多额外的操作，这对 CPU 的开销很大，大大降低了 CPU 性能。所以有些处理器才不情愿为你做这些工作。
五、历史
最初的 68000 处理器的存取粒度是双字节，没有应对非对齐内存地址的电路系统。当遇到非对齐内存地址的存取时，它将抛出一个异常。最初的 Mac OS 并没有妥善处理这个异常，它会直接要求用户重启机器。
随后的 680x0 系列，像 68020，放宽了这个的限制，支持了非对齐内存地址存取的相关操作。这解释了为什么一些在 68020 上正常运行的旧软件会在 68000 上崩溃。这也解释了为什么当时一些老 Mac 编程人员会将指针初始化成奇数地址。在最初的 Mac 机器上如果指针在使用前没有被重新赋值成有效地址，Mac 会立即跳到调试器。通常他们通过检查调用堆栈会找到问题所在。
所有的处理器都使用有限的晶体管来完成工作。支持非对齐内存地址的存取操作会消减“晶体管预算”，这些晶体管原本可以用来提升其他模块的速度或者增加新的功能。
以速度的名义牺牲非对齐内存存取功能的一个例子就是 MIPS。为了提升速度，MIPS 几乎废除了所有的琐碎功能。
PowerPC 各取所长。目前所有的 PowerPC 都在硬件上支持非对齐的 32 位整型的存取。虽然牺牲掉了一部分性能，但这些损失在逐渐减少。
Power 是 1991 年，Apple、IBM、Motorola 组成的 AIM 联盟所发展出的微处理器架构。PowerPC 是整个 AIM 联盟平台的一部分，并且是到目前为止唯一的一部分。但苹果电脑自 2005 年起，将旗下电脑产品转用 Intel CPU。
现今的 PowerPC 处理器缺少对非对齐的 64-bit 浮点型数据的存取的硬件支持。当被要求从非对齐内存读取浮点数时，PowerPC 会抛出异常并让操作系统在软件层面处理内存对齐。软件解决内存对齐要比硬件慢得多。经过 IBM 在 PowerPC 测试，他们效率的差异大概在 4610%。
六、总结
在 iOS 开发中编译器会帮我们进行内存对齐。所以这些问题都无需考虑。但如果编译器没有提供这些功能，而且 CPU 也不支持读取非对齐数据，CPU 就会抛出硬件异常交给操作系统处理，从而产生 4610% 的差异。如果 CPU 支持读取非对齐数据，相比对齐数据，你还是要承担额外的开销造成的损失。诚然，这种损失绝不会像 4610% 那么大，但还是不能忽略的。
了解了这些后，当我们再声明结构体时就应该合理的安排内部数据的顺序，从而使其占用尽可能小的内存。你也许觉得这并没有什么卵用，但苹果在 Runloop 的源码中就使用了 _padding[3] 来手动对齐内存。
注意：Vc,Vs等编译器默认是#pragma pack(8)，gcc 默认是 #pragma pack(4)，并且 gcc 只支持 1,2,4 对齐。
