结构体对齐详解

阅读说明

1、在文中要注意#pragma pack（）函数的使用

2、本文中博主用于演示的是linux32位系统

3、如果有不同意见可以在下面评论区一起讨论（windows下的我不是很清楚，听说例二windows下的那个分析有问题,1B+8B=13B，阅读分析时请注意）

4、我觉得这篇文章解释的非常清楚，看完之后醍醐灌顶

5、标注为“注”的是我的注释

我认为结构体对齐要考虑三点：

1、确认结构体对齐值（模数），通过比较【#pragma pack指定的数值】、【未指定#pragma pack时，系统默认的对齐模数（32位系统为4字节，64位为8字节）】和【结构体内部最大的基本数据类型成员】长度中数值较小者。结构体的长度应该是该模数的整数倍。

2、确定成员自身对齐模数（首先需要明确的是各个数据成员的对齐模数，对齐模数和数据成员本身的长度以及pragma pack编译参数有关，其值是二者中最小数）

3、结构体对齐

我对结构体大小的计算方法和本文作者讲解的方法有所不一样，但是文章作者的图画的很清晰。

我是这样理解例一的：我在linux64位下操作

struct my_struct {     char a;     long double b; };

首先确定对齐模数，long double在64位下对齐模数是16，长度为16，大于64位的8，这里没有调用#pragma pack（），因此综合考虑后，结构体对齐模数为16.
char占一个字节，因为成员自身要对齐，后面填充15个字节，16是long double模数的最小整数倍，long double长度为16，所以1+15+16=32，最后考虑结构体自身对齐，因为32是16的倍数，因此该结构体大小为32.

改进代码：

struct A{    char a;    long double d;      char x;}A;int main(){    printf("%d\n",sizeof(A))；    return 0;}

结果：

[fanmaolin@Centeros pen]$ ./a.out 48

下面是转载文章：

转载自：http://www.cnblogs.com/motadou/archive/2009/01/17/1558438.html 作者：酱油和醋

1 – 结构体数据成员对齐的意义

许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的起始地址的值是某个数k的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。
比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。

2 – 结构体对齐包括两个方面的含义

1)结构体总长度；
2)结构体内各数据成员的内存对齐，即该数据成员相对结构体的起始位置；

3 – 结构体大小的计算方法和步骤

1)将结构体内所有数据成员的长度值相加，记为sum_a；

2)将各数据成员为了内存对齐，按各自对齐模数而填充的字节数累加到和sum_a上，记为sum_b。对齐模数是#pragma pack指定的数值以及该数据成员自身长度中数值较小者。该数据相对起始位置应该是对齐模式的整数倍;

3)将和sum_b向结构体模数对齐，该模数是【#pragma pack指定的数值】、【未指定#pragma pack时，系统默认的对齐模数（32位系统为4字节，64位为8字节）】和【结构体内部最大的基本数据类型成员】长度中数值较小者。结构体的长度应该是该模数的整数倍。

注 ：默认的系统长度应该是比较大的，我在例一中的实际结果显示结构体对齐模数应该是16，那么还是小于系统的长度。

4 – 结构体大小计算举例

在计算之前，我们首先需要明确的是各个数据成员的对齐模数，对齐模数和数据成员本身的长度以及pragma pack编译参数有关，其值是二者中最小数。如果程序没有明确指出，就需要知道编译器默认的对齐模数值。下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数。

注 ： 上面这句话初看没什么，等到实际操作的时候就会发现他的威力。比如例二，如果不加pragma pack（2），在64位linux下，执行结果为32，但是加上后，变为了18，结构体对齐模数和数据成员对齐模数都出现了变化，变为2.

例子1：

struct my_struct {     char a;     long double b; };

此例子Windows和Linux计算方法有些许不一致。
在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B = 9B –> sum_a = 9B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 16B –> sum_b = 16 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B –> sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 3 = 16B –> sum_b = 16 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为12后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1-2所示。

例子2：

#pragma pack(2) struct my_struct {     char a;     long double b; }; 

例子1和例子2不同之处在于例子2中使用了#pragma pack(2)编译参数，它强制指定对齐模数是2。此例子Windows和Linux计算方法有些许不一致。

在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B = 13B –> sum_a = 9B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 10B –> sum_b = 10 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的5倍，不需再次对齐。
综上3步，可知结构体的长度是10B，各数据成员在内存中的分布如图2-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B –> sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_a + 1 = 14B –> sum_b = 14 B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为2，所以结构体对齐模数是2。sum_b是2的7倍，不需再次对齐。
综上3步，可知结构体的长度是14B，各数据成员在内存中的分布如图2-2所示。

例子3：

struct my_struct {     char a;     double b;     char c; }; 

前两例中，数据成员在Linux和Windows下都相同，例3中double的对齐模数在Linux中是4，在Windows下是8，针对这种模数不相同的情况加以分析。
在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B –> sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_a + 7 = 17B –> sum_b = 17B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b应该是8的整数倍，所以要在结构体后填充8*3 - 17 = 7个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图3-1所示。

在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B，sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 13B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b应该是4的整数倍，所以要在结构体后填充4*4 - 13 = 3个字节。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图3-2所示。

例子4：

struct my_struct {     char a[11];     int b;     char c; }; 

此例子Windows和Linux计算方法一样，如下：
步骤1：所有数据成员自身长度和：11B + 4B + 1B = 16B –> sum_a = 16B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_a + 1 = 17B –> sum_b = 17B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充4*5 - 17 = 1个字节。
综上3步，可知结构体的长度是20B，各数据成员在内存中的分布如图4所示。

例子5：

struct my_test {     int my_test_a;     char my_test_b; }; struct my_struct {     struct my_test a;     double my_struct_a;     int my_struct_b;     char my_struct_c; }; 

例子5和前几个例子均不同，在此例子中我们要计算struct my_struct的大小，而my_struct中嵌套了一个my_test结构体。这种结构体应该如何计算呢？原则是将my_test在my_struct中先展开，然后再计算，即是展开成如下结构体：

struct my_struct{    int my_test_a;    char my_test_b;    double my_struct_a;    int my_struct_b;    char my_struct_c;}; 

此例子Windows中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B –> sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充3个字节：sum_a + 3 = 21B –> sum_b = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b是8的整数倍，需在结构体后填充3*8 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。

此例子Linux中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充6*4 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图5所示。

5 – 源代码附录

上面的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上测试验证。下面是测试程序。

#include <iostream>#include <stdio.h>using namespace std;int main(){    cout << "sizeof(char)        = " << sizeof(char) << endl;    cout << "sizeof(short)       = " << sizeof(short) << endl;    cout << "sizeof(int)         = " << sizeof(int) << endl;    cout << "sizeof(long)        = " << sizeof(long) << endl;    cout << "sizeof(float)       = " << sizeof(float) << endl;    cout << "sizeof(double)      = " << sizeof(double) << endl;    cout << "sizeof(long long)   = " << sizeof(long long) << endl;    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;        // 例子1    {        struct my_struct         {             char a;             long double b;         };        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;        struct my_struct data;        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);    }    // 例子2    {        #pragma pack(2)         struct my_struct         {             char a;             long double b;         };         #pragma pack()        struct my_struct data;        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);    }    // 例子3    {        struct my_struct         {             char a;             double b;             char c;         };         struct my_struct data;        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);    }    // 例子4    {        struct my_struct         {              char a[11];              int b;              char c;          };        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;        struct my_struct data;        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);    }    // 例子5     {        struct my_test         {             int my_test_a;             char my_test_b;         };         struct my_struct         {             struct my_test a;             double my_struct_a;             int my_struct_b;             char my_struct_c;         };         cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;        struct my_struct data;        printf("my_struct->my_test_a  : %u\n"            "my_struct->my_test_b  : %u\n"            "my_struct->my_struct_a: %u\n"            "my_struct->my_struct_b: %u\n"            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b,             &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);    }    return 0;}

执行结果：

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linuxsizeof(char)        = 1sizeof(short)       = 2sizeof(int)         = 4sizeof(long)        = 8sizeof(float)       = 4sizeof(double)      = 8sizeof(long long)   = 8sizeof(long double) = 16exapmle-1: sizeof(my_struct) = 32my_struct->a: 2163695552my_struct->b: 2163695568exapmle-2: sizeof(my_struct) = 18my_struct->a: 2163695680my_struct->b: 2163695682exapmle-3: sizeof(my_struct) = 24my_struct->a: 2163695648my_struct->b: 2163695656my_struct->c: 2163695664example-4: sizeof(my_struct) = 20my_struct->a: 2163695616my_struct->b: 2163695628my_struct->c: 2163695632example-5: sizeof(my_struct) = 24my_struct->my_test_a  : 2163695584my_struct->my_test_b  : 2163695588my_struct->my_struct_a: 2163695592my_struct->my_struct_b: 2163695600my_struct->my_struct_c: 2163695604

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linuxsizeof(char)        = 1sizeof(short)       = 2sizeof(int)         = 4sizeof(long)        = 4sizeof(float)       = 4sizeof(double)      = 8sizeof(long long)   = 8sizeof(long double) = 12exapmle-1: sizeof(my_struct) = 16my_struct->a: 3213889904my_struct->b: 3213889908exapmle-2: sizeof(my_struct) = 14my_struct->a: 3213889890my_struct->b: 3213889892exapmle-3: sizeof(my_struct) = 16my_struct->a: 3213889872my_struct->b: 3213889876my_struct->c: 3213889884example-4: sizeof(my_struct) = 20my_struct->a: 3213889852my_struct->b: 3213889864my_struct->c: 3213889868example-5: sizeof(my_struct) = 24my_struct->my_test_a  : 3213889828my_struct->my_test_b  : 3213889832my_struct->my_struct_a: 3213889836my_struct->my_struct_b: 3213889844my_struct->my_struct_c: 3213889848

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwinsizeof(char)        = 1sizeof(short)       = 2sizeof(int)         = 4sizeof(long)        = 4sizeof(float)       = 4sizeof(double)      = 8sizeof(long long)   = 8sizeof(long double) = 12exapmle-1: sizeof(my_struct) = 16my_struct->a: 2272336my_struct->b: 2272340exapmle-2: sizeof(my_struct) = 14my_struct->a: 2272322my_struct->b: 2272324exapmle-3: sizeof(my_struct) = 24my_struct->a: 2272296my_struct->b: 2272304my_struct->c: 2272312example-4: sizeof(my_struct) = 20my_struct->a: 2272276my_struct->b: 2272288my_struct->c: 2272292example-5: sizeof(my_struct) = 24my_struct->my_test_a  : 2272248my_struct->my_test_b  : 2272252my_struct->my_struct_a: 2272256my_struct->my_struct_b: 2272264my_struct->my_struct_c: 2272268