[C++知识库]C++字节对齐（地址对齐）

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、默认字节对齐演示

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

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

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

（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，刚好为结构体的字节边界数（即结构体中占用最大空间的类型所占用的字节数sizeof(double)=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、显示指定对齐方式

编译器对结构体的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。?
编译器中提供了#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; 3+8
    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(double)）的倍数，所以编译器不再扩充多余的空白字节了，所以sizeof(test)=16

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

所有的成员变量都分配了空间，总共的字节数为1+7+8+4=20，不满足8的倍数，所以编译器自动在最后一个变量后面扩充4个字节

通过#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?>=?sizeof(double)）的倍数，所以编译器在最后一个成员后边扩充4个空白字节，所以sizeof(test)=1+7+8+4+4=24

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

#pragma pack(8)
struct S1{
    char a;//偏移量为0，满足1（8 > sizeof(char)）的倍数,分配1字节
    long b;//编译器扩充7字节，此时偏移量是8，满足8（8 >= sizeof(long)）的倍数,分配8字节
};
此时S1分配的字节数是1+7+8=16，满足8（8 >= sizeof(long)）的倍数，所以sizeof(S1)=16
struct S2 {
    char c;//偏移量为0，满足1（8 > sizeof(char)）的倍数，分配1字节
    struct S1 d;//编译器扩充7字节，以满足偏移量是8（8 >= 8）的倍数，分配16字节
    long long e;//此时的偏移量是1+7+16=24字节，满足偏移量是8（8 >= sizeof(long long)）的倍数，分配8字节
};
此时，S2分配的字节数是1+7+16+8=32，满足8的倍数，所以sizeof(S2)=32
#pragma pack()

在x86_64环境下，sizeof(long)=sizeof(long long)=8

成员对齐有一个重要的条件，即每个成员分别对齐。即每个成员按自己的方式对齐，也就是说上面虽然指定了按8字节对齐，但并不是所有的成员都是以8字节对齐。其对齐的规则是，每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里是8字节)中较小的一个对齐，并且结构体的长度必须为所用过的所有对齐参数的整数倍，不够就补空字节。
　　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个字节是扩充的。

这里有三点很重要:
(1)每个成员分别按自己的方式对齐,并能最小化长度。
(2)复杂类型(如结构体)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。
(3)对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。