1、什么是字节对齐

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

说白了字节对齐，就是地址对齐，变量的存放不是一个挨着一个按照变量大小进行空间分配，而是按照一定的规则在指定的地址上给变量逐一分配空间。

2、字节对齐的原因和作用

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

3、举例说明

定义如下结构体：

struct MyStruct
{
        double d1;
        char c1;
        int type;
};

 在没有接触字节对齐相关知识前，大家可能觉得MyStruct这个类型所占用的字节数肯定等于sizeof(double)+sizeof(char)+sizeof(int)=8+1+4=13，其实不是这样的，经上机测试，sizeof(MyStruct) = 16

多出来的字节是干嘛使得？没什么结构体大小不等于各个成员类型大小之和呢？

其实这是编译器对成员的存放地址做了“对齐”处理，导致结构体的大小不等于各个成员的大小之和，目的就是为了提高CPU对变量的存取速度。

4、常用类型的默认对齐方式(x86_64)

偏移量：变量存放的起始地址 – 结构体的起始地址

注意：上面表格只是列出了变量的默认对齐方式，变量的对齐方式是会变的，当编译器的对齐方式小于变量的默认对齐方式时，变量就会使用编译器的对齐方式；否则使用变量的默认对齐方式。

各成员变量在存放的时候会根据在结构体中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节编译器会自动填充。同时编译器会确保结构体的总大小为所使用的最大对齐方式的整数倍（这里不完全正确，姑且这样理解，下文有结构体总大小的完整条件），在为最后一个成员变量申请空间后，会根据需要自动填充空缺的字节。 

5、默认字节对齐演示(x86_64环境)

在x86_64环境下，编译器缺省的对齐方式是8字节。

下面用前面的例子来说明编译器到底怎么样来存放结构体的。 

struct MyStruct
{
        double d1;//8 >= sizeof(double)，所以该变量使用8字节对齐，偏移量是8的倍数即可。
        char c1;//8 >= sizeof(char)，所以该变量使用1字节对齐，偏移量是1的倍数即可。
        int type;//8 >= sizeof(int)，所以该变量使用4字节对齐，偏移量是4的倍数即可。
};

为上面的结构体分配空间的时候，编译器根据成员变量出现的顺序和对齐方式，

（1）先为第一个成员d1分配空间，其起始地址跟结构体的起始地址相同（偏移量为0，刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；

（2）接下来为第二个成员c1分配空间，这时下一个可以分配的地址对于结构体的起始地址的偏移量为8，是sizeof(char)的倍数，所以把c1存放在偏移量为8的地方满足对齐方式，该成员变量占用 sizeof(char)=1个字节；
（3）接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构体的起始地址的偏移量为9，不是sizeof (int)=4的倍数，为了满足对齐方式对偏移量的约束问题，编译器自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构体的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；
（4）这时整个结构体的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为所使用的最大对齐方式8的倍数，所以不再为结构体分配多余的空白字节了。

所以整个结构体的大小为：sizeof(MyStruct)=8+1+ 3+4=16，其中有3个字节是编译器自动填充的，没有放任何有意义的东西。 

下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况：

struct MyStruct
{
        char c1;
        double d1;
        int type;
};

这个结构占用的空间为多大呢？在x86_64环境下，可以得到sizeof(MyStruct)为24。结合上面提到的分配空间的一些原则，分析下编译器怎么样为上面的结构体分配空间的。

struct MyStruct
{
        char c1;//偏移量为0，满足对齐方式，占用1字节
        double d1;//下一个地址偏移量为1，不满足偏移量是sizeof(double)的整数倍，需要补足7个字节，这时偏移量为8，满足对齐方式，然后从该地址分配8个字节给d1
        int type;//下一个地址偏移量是1+7+8=16，是sizeof(int)的整数倍，编译器直接在这里分配4字节作为type的存储空间
};
此时，结构体占用的字节数=1+7+8+4=20，不满足结构体总的字节数是使用的最大对齐方式8的倍数，所以编译器在最后一个成员type后边追加4字节

所以该结构体总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。其中有7+4=11个字节是编译器自动填充的，没有放任何有意义的东西。 

6、显示指定编译器对齐方式

编译器有自己的默认对齐方式，在x86_64系统上是8字节对齐，在x86_32系统上是4字节对齐，当然我们也可以告诉编译器，使用哪一种对齐方式来给结构体分配空间。

编译器中提供了#pragma pack(n)来设定编译器以n字节对齐方式，这里的n可以是1,2,4,8,16。

n字节对齐就是说变量存放的起始地址的偏移量是n的倍数，分下面两种情况（两者相比，取小）：

（1）如果n大于等于该变量所占用的字节数，那么偏移量必须满足该变量的默认对齐方式。
（2）如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足该变量默认的对齐方式。
结构体的总大小也有个约束条件，分下面两种情况（两者相比，取小）：

（1）如果n大于所有成员的对齐方式，则结构体的大小是最大成员对齐方式的倍数。

（2）否则必须为n的倍数。

7、显示对齐方式演示

#pragma pack(push) 　　　　　　　　　　　　　　　　　　//保存对齐状态 
#pragma pack(4)　　　　　　　　　　　　　　　　　　　　//设定编译器为4字节对齐 
struct test 
{ 
    char m1; //1字节对齐
    double m2; //4字节对齐
    int m3; //4字节对齐
}; 
#pragma pack(pop)　　　　　　　　　　　　　　　　　　 //恢复对齐状态 

通过#pragma pack(4)指定编译器以4字节倍数对齐。

（1）首先为m1分配空间，其偏移量为0，满足1（4 >= sizeof(char)）的倍数，分配1字节给m1

（2）接着为m2分配空间，当前偏移量为1，不满足4（4 < sizeof(double) ）的倍数，编译器填充3个空白字节，此时偏移量为4，满足4的倍数，分配8字节给m2

（3）接着为m3分配空间，当前偏移量是1+3+8=12，满足4（4 >= sizeof(int)）的倍数，分配4字节给m3

此时，已经给所有的成员变量分配了1+3+8+4=16个字节，满足4（n >= 最大对齐方式4）的倍数，所以编译器不再扩充多余的空白字节了，所以sizeof(test)=16

#pragma pack(push) 　　　　　　　　　　　　　　　　　　//保存对齐状态 
#pragma pack(16)　　　　　　　　　　　　　　　　　　　　//设定为16字节对齐 
struct test 
{ 
    char m1; //1字节对齐
    double m2; //8字节对齐
    int m3; //4字节对齐
}; 
#pragma pack(pop)　　　　　　　　　　　　　　　　　　 //恢复对齐状态 

通过#pragma pack(16)指定编译器以16字节倍数对齐。

（1）首先为m1分配空间，其偏移量为0，满足1（16 >= sizeof(char)）的倍数，分配1字节给m1

（2）接着为m2分配空间，当前偏移量为1，不满足8（16 >= sizeof(double) ）的倍数，编译器填充7个空白字节，此时偏移量为8，满足8的倍数，分配8字节给m2

（3）接着为m3分配空间，当前偏移量是1+7+8=16，满足4（16 >= sizeof(int)）的倍数，分配4字节给m3

此时，已经给所有的成员变量分配了1+7+8+4=20个字节，不满足8（n=16 >= 最大对齐方式8）的倍数，所以编译器在最后一个成员后边扩充4个空白字节，所以sizeof(test)=1+7+8+4+4=24

8、数据成员是结构体的显示对齐演示(x86_64)

#pragma pack(8)
struct S1{
    char a;//对齐方式1字节
    long b;//对齐方式8字节
};
此时S1分配的字节数是1+7+8=16，满足8（8 >= sizeof(long)）的倍数，所以sizeof(S1)=16
struct S2 {
    char c;//对齐方式1字节
    struct S1 d;//对齐方式8字节（结构体作为成员时，其对齐方式是它的最大成员对齐方式）
    long long e;//对齐方式8字节
};
此时，S2分配的字节数是1+7+16+8=32，满足8（8 >= 最大对齐方式8）的倍数，所以sizeof(S2)=32
#pragma pack()

当成员类型是结构体时，需要先将该成员内部对齐，并且保证该成员的总体大小约束，然后再把该成员在父结构体中对齐。

S1中，成员a是1字节，默认按1字节对齐，指定对齐参数为8，这两个值中取1，a按1字节对齐；成员b是8个字节，默认是按8字节对齐，这时就按8字节对齐，所以sizeof(S1)应该为1+7+8=16。
S2 中，c和S1中的a一样，按1字节对齐；而d 是个结构体，它是16个字节，它按什么对齐呢?对于结构体成员来说，它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个，S1的就是8，所以，成员d就是按8字节对齐；成员e是8个字节，它是默认按8字节对齐，所以sizeof(S2)=1+7+16+8=32。
S1的内存布局：1*******11111111，一共16个字节，中间有7个字节是扩充的。
S2的内存布局：1*******1*******1111111111111111，一共32个字节，中间有7+7个字节是扩充的。