结构体对齐详解

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 pac指定的数值和结构体内部最大的基本数据类型成员长度中数值较小者。结构体的长度应该是该模数的整数倍。

4 -- 结构体大小计算举例

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

 

  charshortintlongdoublelong doubleWindows长度124488模数124488Linux长度1244812模数124444

 

例子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; }; #pragma pack()

例子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>int main(){ ////////////////////////////////////////////////////////////////////////////////////////// // 例子1 {  struct my_struct   {    char a;    long double b;   };  std::cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << std::endl;    struct my_struct data;   printf("my_struct->a: %u\n"      "my_struct->b: %u\n"      "sizeof(long double): %u\n", &data.a, &data.b, sizeof(long double));  } ////////////////////////////////////////////////////////////////////////////////////////// // 例子2 {  #pragma pack(2)   struct my_struct   {    char a;    long double b;   };   #pragma pack()  struct my_struct data;   std::cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << std::endl;    printf("my_struct->a: %u\n"      "my_struct->b: %u\n"      "sizeof(long double): %u\n", &data.a, &data.b, sizeof(long double)); } ////////////////////////////////////////////////////////////////////////////////////////// // 例子3 {  struct my_struct   {    char a;    double b;    char c;   };    struct my_struct data;   std::cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << std::endl;    printf("my_struct->a: %u\n"      "my_struct->b: %u\n"      "my_struct->c: %u\n", &data.a, &data.b, &data.c); } ////////////////////////////////////////////////////////////////////////////////////////// // 例子4 {  struct my_struct   {     char a[11];     int b;     char c;    };    std::cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << std::endl;    struct my_struct data;  printf("my_struct->a: %u\n"      "my_struct->b: %u\n"      "my_struct->c: %u\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;   };   std::cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << std::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;}

转自：http://www.cnblogs.com/motadou/archive/2009/01/17/1558438.html

案例：
内存对齐”应该是编译器的“管辖范围”。编译器为程序中的每个“数据单元”安排在适当的位置上。但是C语言的一个特点就是太灵活，太强大，它允许你干预“内存对齐”。如果你想了解更加底层的秘密，“内存对齐”对你就不应该再透明了。
一、内存对齐的原因大部分的参考资料都是如是说的：1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
二、对齐规则每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。
对齐步骤：1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。3、结合1、2颗推断：当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。备注：数组成员按长度按数组类型长度计算，如char t[9],在第1步中数据自身长度按1算，累加结构体时长度为9;第2步中，找最大数据长度时，如果结构体T有复杂类型成员A的，该A成员的长度为该复杂类型成员A的最大成员长度。
三、试验我们通过一系列例子的详细说明来证明这个规则吧!我试验用的编译器包括GCC 3.4.2和VC6.0的C编译器，平台为Windows XP + Sp2。
我们将用典型的struct对齐来说明。首先我们定义一个struct：#pragma pack(n) /* n = 1, 2, 4, 8, 16 */struct test_t { int a; char b; short c; char d;};#pragma pack(n)首先我们首先确认在试验平台上的各个类型的size，经验证两个编译器的输出均为：sizeof(char) = 1sizeof(short) = 2sizeof(int) = 4
我们的试验过程如下：通过#pragma pack(n)改变“对齐系数”，然后察看sizeof(struct test_t)的值。
1、1字节对齐(#pragma pack(1))输出结果：sizeof(struct test_t) = 8 [两个编译器输出一致]分析过程：1) 成员数据对齐#pragma pack(1)struct test_t { int a;  /* 长度4 < 1 按1对齐；起始offset=0 0%1=0；存放位置区间[0,3] */ char b;  /* 长度1 = 1 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */ short c; /* 长度2 > 1 按1对齐；起始offset=5 5%1=0；存放位置区间[5,6] */ char d;  /* 长度1 = 1 按1对齐；起始offset=7 7%1=0；存放位置区间[7] */};#pragma pack()成员总大小=8
2) 整体对齐整体对齐系数 = min((max(int,short,char), 1) = 1整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 8 /* 8%1=0 */ [注1]
2、2字节对齐(#pragma pack(2))输出结果：sizeof(struct test_t) = 10 [两个编译器输出一致]分析过程：1) 成员数据对齐#pragma pack(2)struct test_t { int a;  /* 长度4 > 2 按2对齐；起始offset=0 0%2=0；存放位置区间[0,3] */ char b;  /* 长度1 < 2 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */ short c; /* 长度2 = 2 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */ char d;  /* 长度1 < 2 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */};#pragma pack()成员总大小=9
2) 整体对齐整体对齐系数 = min((max(int,short,char), 2) = 2整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 10 /* 10%2=0 */
3、4字节对齐(#pragma pack(4))输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]分析过程：1) 成员数据对齐#pragma pack(4)struct test_t { int a;  /* 长度4 = 4 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */ char b;  /* 长度1 < 4 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */ short c; /* 长度2 < 4 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */ char d;  /* 长度1 < 4 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */};#pragma pack()成员总大小=9
2) 整体对齐整体对齐系数 = min((max(int,short,char), 4) = 4整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /* 12%4=0 */
4、8字节对齐(#pragma pack(8))输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]分析过程：1) 成员数据对齐#pragma pack(8)struct test_t { int a;  /* 长度4 < 8 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */ char b;  /* 长度1 < 8 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */ short c; /* 长度2 < 8 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */ char d;  /* 长度1 < 8 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */};#pragma pack()成员总大小=9
2) 整体对齐整体对齐系数 = min((max(int,short,char), 8) = 4整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /* 12%4=0 */
5、16字节对齐(#pragma pack(16))输出结果：sizeof(struct test_t) = 12 [两个编译器输出一致]分析过程：1) 成员数据对齐#pragma pack(16)struct test_t { int a;  /* 长度4 < 16 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */ char b;  /* 长度1 < 16 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */ short c; /* 长度2 < 16 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */ char d;  /* 长度1 < 16 按1对齐；起始offset=8 8%1=0；存放位置区间[8] */};#pragma pack()成员总大小=9
2) 整体对齐整体对齐系数 = min((max(int,short,char), 16) = 4整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /* 12%4=0 */
转自：http://www.cppblog.com/iuranus/archive/2009/01/06/71388.html