iOS 内存对齐原则及结构体内存对齐

• 内存对齐原则：
  首先我们需要了解一下各种数据类型所占的内存大小，如下表所示：

C	OC	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 short	unichar	2	2
int int32_t	NSIneteger(32位)、Boolean_t(32位)	4	4
unsigned int	Boolean_t(64位)、NSInteger(32位)	4	4
long	NSIneteger(64位)	4	8
unsigned long	NSUIneteger(64位)	4	8
long long	int64_t	8	8
float	CGFloat(32位)	4	4
double	CGFloat(64位)	8	8

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。
Xcode 中默认为#pragma pack(8)。如果在代码执行前加一句#pragma pack(1) 时就代表不进行内存对齐。

• 什么是内存对齐,为什么要对齐?
  TragicJun 发表于 2006-9-18 9:41:00 现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。

• 对齐的作用和原因：
  各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。

• 内存对齐原则：
  1、数据成员对齐规则：结构（struct）（或者联合（union））的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如说是数组，结构体等）的整数倍开始。
  2、结构体作为成员，如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储。
  3、结构体的总的大小，也是就是sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐。

• 结构体内存对齐
  知道内存对齐原则，我们举例说明一下:

struct HFStruct1 {
    char a;      //1{所占字节数}
    double b;   // 8{所占字节数}
    int c;      // 4{所占字节数}
    short d;    // 2{所占字节数}
}struct1;

struct HFStruct2 {
    double a;      //8{所占字节数} 
    int b;     //4{所占字节数}
    char c;    //1{所占字节数} 
    short d;    //2{所占字节数}
}struct2;

首先我们分析结构体struct1，
变量a：占1字节，从0的位置开始，到1截止，故（0，1）存储变量a。
变量b：占8字节，从1开始，根据原则3，要从8的整数倍开始存储，往后移，故（8，15）存储变量b。
变量c：占4字节，从16开始。根据原则3，16是4的整数倍。故从16的位置开始，故（16，20）存储变量c。
变量d：占2字节，从20开始。根据原则3，20是2的整数倍。故从20的位置开始，故（20，22）存储变量d。

然后我们分析结构体struct1，
变量a：占8字节，从0的位置开始，到1截止，故（0，7）存储变量a。
变量b：占4字节，从8开始，根据原则3，8是4的整数倍，故（8，11）存储变量b。
变量c：占1字节，从12开始。根据原则3，12是1的整数倍。故从12的位置开始，故12存储变量c。
变量d：占2字节，从13开始。根据原则3，要从2的整数倍开始存储。故从20的位置开始，故（14，15）存储变量d。

内存结构分析

输出log确认下：
NSLog(@"%lu-%lu",sizeof(struct1),sizeof(struct2));
log输出：24-16

• 结构体嵌套的内存对齐
  上述结构体没有涉及到嵌套的问题：
  下例来看一看结构体嵌套的内存对齐

struct HFStruct3 {
    double a;   //8{所占字节数}
    int b;      //4{所占字节数}
    char c;    //1{所占字节数}
    short d;    //2{所占字节数}
    struct HFStruct1 e;//24{所占字节数}
}struct3;

struct HFStruct4 {
    int a;      //4{所占字节数}
    char b;     //1{所占字节数}
    short c;    //2{所占字节数}
    short d;     //1{所占字节数}
    struct HFStruct1 e;//24{所占字节数}
    struct HFStruct2 f;//16{所占字节数}
}struct4;

首先见到这个不要慌,
1、根据上诉的分析我们知道struct3的内存大小为24、其中struct1里面的最大字节数为：8，struct2的内存大小为16、其中struct2里最大字节数也为8。

2、我们可以算出struct3中不含结构体的内存大小为：16。struct3的最大字节数为8。

3、加入结构体对比其所占的最大字节数，然后取其大者。故struct3的结构体的所占的最大字节数为8。

4、将不含结构体的内存大小➕ 内部结构体所占的内存大小，得出结果为：24 + 16 = 40，根据原则3，而40刚好是最大字节数的整数倍。故此struct3结构体的内存大小为：40.

5、如法炮制，计算struct4不含结构体的大小为：12。不含结构体的内存大小➕ 内部结构体所占的内存大小，得出结果为： 12 + 24 + 16 = 52,而52不是最大字节的整数倍，根据原则3，故要在最后填充字节数，到最大的字节的整数倍为止。故此struct4的结构体的内存大小为56.

验证

输出log确认下：
NSLog(@"%lu-%lu",sizeof(struct3),sizeof(struct4));
log输出：45-56

总结：结构体嵌套的内存对齐，我们可以简单的将其单个的结构体的内存大小相加，然后通过原则3，结构体的大小内部最大成员的字节数的整数倍，我们可以得到起结构体嵌套的内存对齐的大小。