编译器为何进行内存对齐

A. 什么是数据的对齐为什么要对齐

有关字节对齐的介绍：

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

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

对齐的实现
通常，我们写程序的时候，不需要考虑对齐问题。编译器会替我们选择适合目标平台的对齐策略。当然，我们也可以通知给编译器传递预编译指令而改变对指定数据的对齐方法。
但是，正因为我们一般不需要关心这个问题，所以因为编辑器对数据存放做了对齐，而我们不了解的话，常常会对一些问题感到迷惑。最常见的就是struct数据结构的sizeof结果，出乎意料。为此，我们需要对对齐算法所了解。

对齐的算法：

设结构体如下定义：
struct A
{
int a;
char b;
short c;
};
结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个。所以A用到的空间应该是7字节。但是因为编译器要对数据成员在空间上进行对齐。
所以使用sizeof(strcut A)值为8。
现在把该结构体调整成员变量的顺序。
struct B
{
char b;
int a;
short c;
};
这时候同样是总共7个字节的变量，但是sizeof(struct B)的值却是12。
下面我们使用预编译指令#progma pack (value)来告诉编译器，使用我们指定的对齐值来取代缺省的。
#progma pack (2) /*指定按2字节对齐*/
struct C
{
char b;
int a;
short c;
};
#progma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。

修改对齐值为1：
#progma pack (1) /*指定按1字节对齐*/
struct D
{
char b;
int a;
short c;
};
#progma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。

对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
这里面有四个概念值：
1.数据类型自身的对齐值：就是上面交代的基本数据类型的自身对齐值。
2.指定对齐值：#progma pack (value)时的指定对齐值value。
3.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。
有了这些值，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析：
分析例子B；
struct B
{
char b;
int a;
short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x0000%1=0.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4，所以只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为 2，所以有效对齐值也是2，可以存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。所以从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求， 0x0009到0x0000=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B 共有12个字节,sizeof(struct B)=12;

同理,分析上面例子C：
#progma pack (2) /*指定按2字节对齐*/
struct C
{
char b;
int a;
short c;
};
#progma pack () /*取消指定对齐，恢复缺省对齐*/
第一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1= 0;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放
在0x0006、0x0007中，符合 0x0006%2=0。所以从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C 只占用0x0000到0x0007的八个字节。所以sizeof(struct C)=8.

B. 下载程序时字节对齐

一、快速理解

1、内存对齐原则：

第一个成员的首地址为0.
每个成员的首地址是自身大小的整数倍
结构体的总大小，为其成员中所含最大类型的整数倍。
2、什么是字节对齐？

在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每个成员按其自然边界（alignment）分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。
为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”.
比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.
3、 字节对齐有什么作用？

字节对齐的作用不仅是便于cpu快速访问。
同时合理的利用字节对齐可以有效地节省存储空间。
对于32位机来说，4字节对齐能够使cpu访问速度提高，比如说一个long类型的变量，如果跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。
但是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度降低。所以这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 是默认4字节对齐。
4、 更改C编译器的缺省字节对齐方式

在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变缺省的对界条件：

使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。
使用伪指令#pragma pack()，取消自定义字节对齐方式。
另外，还有如下的一种方式：

__attribute((aligned (n)))，让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n，则按照最大成员的长度来对齐。 ·
attribute ((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。
5、 举例说明

例1

struct test
{
char x1;
short x2;
float x3;
char x4;
};
1
2
3
4
5
6
7
1
2
3
4
5
6
7
由于编译器默认情况下会对这个struct作自然边界（有人说“自然对界”我觉得边界更顺口）对齐，结构的第一个成员x1，其偏移地址为0，占据了第1个字节。第二个成员x2为short类型，其起始地址必须2字节对界。
因此，编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4恰好落在其自然边界地址上，在它们前面不需要额外的填充字节。
在test结构中，成员x3要求4字节对界，是该结构所有成员中要求的最大边界单元，因而test结构的自然对界条件为4字节，编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

例2

#pragma pack(1) //让编译器对这个结构作1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐，恢复为默认4字节对齐
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
这时候sizeof(struct test)的值为8。

例3

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
这时候sizeof(struct test)的值仍为8。

二、深入理解

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

先让我们看几个例子吧(32bit,x86环境,gcc编译器):

设结构体如下定义：

struct A
{
int a;
char b;
short c;
};
struct B
{
char b;
int a;
short c;
};
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)
short:2(有符号无符号同)
int:4(有符号无符号同)
long:4(有符号无符号同)
float:4 double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12一、快速理解

1、内存对齐原则：

第一个成员的首地址为0.
每个成员的首地址是自身大小的整数倍
结构体的总大小，为其成员中所含最大类型的整数倍。
2、什么是字节对齐？

在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每个成员按其自然边界（alignment）分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。
为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”.
比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.
3、 字节对齐有什么作用？

字节对齐的作用不仅是便于cpu快速访问。
同时合理的利用字节对齐可以有效地节省存储空间。
对于32位机来说，4字节对齐能够使cpu访问速度提高，比如说一个long类型的变量，如果跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。
但是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度降低。所以这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 是默认4字节对齐。
4、 更改C编译器的缺省字节对齐方式

在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变缺省的对界条件：

使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。
使用伪指令#pragma pack()，取消自定义字节对齐方式。
另外，还有如下的一种方式：

__attribute((aligned (n)))，让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n，则按照最大成员的长度来对齐。 ·
attribute ((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。
5、 举例说明

例1

struct test
{
char x1;
short x2;
float x3;
char x4;
};
1
2
3
4
5
6
7
1
2
3
4
5
6
7
由于编译器默认情况下会对这个struct作自然边界（有人说“自然对界”我觉得边界更顺口）对齐，结构的第一个成员x1，其偏移地址为0，占据了第1个字节。第二个成员x2为short类型，其起始地址必须2字节对界。
因此，编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4恰好落在其自然边界地址上，在它们前面不需要额外的填充字节。
在test结构中，成员x3要求4字节对界，是该结构所有成员中要求的最大边界单元，因而test结构的自然对界条件为4字节，编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

例2

#pragma pack(1) //让编译器对这个结构作1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐，恢复为默认4字节对齐
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
这时候sizeof(struct test)的值为8。

例3

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
这时候sizeof(struct test)的值仍为8。

二、深入理解

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

先让我们看几个例子吧(32bit,x86环境,gcc编译器):

设结构体如下定义：

struct A
{
int a;
char b;
short c;
};
struct B
{
char b;
int a;
short c;
};
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)
short:2(有符号无符号同)
int:4(有符号无符号同)
long:4(有符号无符号同)
float:4 double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12

C. 内存对齐详解

1、什么是内存对齐
假设我们声明两个变量：

2、结构体内存对齐规则

结构体所占用的内存与其成员在结构体中的声明顺序有关，其成员的内存对齐规则如下：

（1）每个成员分别按自己的对齐字节数和PPB（指定的对齐字节数，32位机默认为4）两个字节数最小的那个对齐，这样可以最小化长度。

（2）复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式，这样在成员是复杂类型时，可以最小化长度。

（3）结构体对齐后的长度必须是成员中最大的对齐参数（PPB）的整数倍，这样在处理数组时可以保证每一项都边界对齐。

（4）计算结构体的内存大小时，应该列出每个成员的偏移地址，则其长度=最后一个成员的偏移地址+最后一个成员数的长度+最后一个成员的调整参数（考虑PPB）。

3、案例讲解：

————————————————
最后输出的结果为：8

4、注意的问题
（1）字节对齐取决于编译器；
（2）一定要注意PPB大小，PPB大小由pragam pack(n)指定；
（3）结构体占用的字节数要能够被PPB整除。
（4）总结出一个公式：结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) +sizeof( trailing padding )

————————————————
原文链接： https://blog.csdn.net/SzMinglove/java/article/details/8143056

D. 结构体内存对齐

结构体内存对齐

一、结构体对齐的三大原则

1、数据成员对齐规则：结构（struct）(或联合体(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员大小（只要该成员有子成员，比如说是数组、结构体等）的整数倍开始（比如int为4字节，则要从4的整数倍地址开始存储）

2、结构体作为成员：如果一个结构体里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（struct a里存有struct b，b里面有char、int 、double等元素，那b应该从8的整数倍开始存储）

3、收尾工作：结构体的总大小，也就是sizeof的结果，必须是其内部最大成员的整数倍，不足的要补齐。

首先，我们看一下各个数据类型在不同操作系统中所占的位数

二、内存对齐规则的应用

图中输出结果是24，为什么是24呢？

a 为double类型，占8个字节，又因为是第一个成员，起始值对应offset为0的位置。又因为占8个字节，所以a对应的是偏移量为8的地址空间

b 为char类型，占1个字节，对齐到1的整数倍，也就是下一个地址空间。

c 为int类型，占4个字节，对齐到4的整数倍，对齐数为12，偏移量为4的地址空间

d 为short类型，占2个字节，对齐到2的整数倍，对齐数为16，偏移量为2的地址空间

结构体的总大小，必须是其内部最大成员的整数倍，不足的要补齐，struct1中最大的成员为double类型，那么结构体的总大小即为8的整数倍，目前已经占了17字节，所以总大小应为24个字节

我们再看一下下面的输出又是多少呢？

输出结果是16。

如图a不变

b 为int类型，占4个字节，对齐到4的整数倍，对齐数为8，偏移量为4的地址空间

c 为char类型，占1个字节，对齐到1的整数倍，也就是下一个地址空间。

d 为short类型，占2个字节，对齐到2的整数倍，对齐数为14，偏移量为2的地址空间

又因为内存对齐原则，所以结构体的总大小为16个字节

那么结构体是否可以嵌套使用呢，嵌套使用的话，内存又该如何计算呢？

这里的输出结果是多少呢。我们来计算一下

如图a不变

b 为int类型，占4个字节，对齐到4的整数倍，对齐数为8，偏移量为4的地址空间

c 为char类型，占1个字节，对齐到1的整数倍，也就是下一个地址空间。

d 为short类型，占2个字节，对齐到2的整数倍，对齐数为14，偏移量为2的地址空间

e 为int类型，占4个字节，对齐到4的整数倍，对齐数为16，偏移量为4的地址空间

已知struct1占24个字节，double 占8个字节，不知道为什么的请往上看。

结构体作为成员：如果一个结构体里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储（struct a里存有struct b，b里面有char、int 、double等元素，那b应该从8的整数倍开始存储）

所以struct1 应该从8的整数倍开始存储

那么struct1 占24个字节，对齐到8的整数倍，对齐数为24，偏移量为24的地址空间

所以结构体的总大小为48个字节

三、为什么要内存对齐呢？

（一）性能上的提升

从内存占用的角度讲，对齐后比未对齐有些情况反而增加了内存分配的开支，是为了什么呢？

数据结构(尤其是栈)应该尽可能地在自然边界上对齐，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。最重要的是提高内存系统的性能。

（二）跨平台

有些硬件平台并不能访问任意地址上的任意数据的，只能处理特定类型的数据，否则会导致硬件层级的错误。

有些CPU（如基于 Alpha，IA-64，MIPS，和 SuperH 体系的）拒绝读取未对齐数据。当一个程序要求这些 CPU 读取未对齐数据时，这时 CPU 会进入异常处理状态并且通知程序不能继续执行。

举个例子，在 ARM，MIPS，和 SH 硬件平台上，当操作系统被要求存取一个未对齐数据时会默认给应用程序抛出硬件异常。所以，如果编译器不进行内存对齐，那在很多平台的上的开发将难以进行。

E. 内存对齐的规则

为了加快计算机的取数速度，编译器默认对内存进行字节对齐。对结构体（包括类）进行字节对齐的原则是：
1）结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2）结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

struct SByte1
{
double d; // 偏移量0~7
char j; // 偏移量8
int a; // 偏移量12~15，由于9不能整除4，故先填充9~11
};
sizeof(SByte1); // = 16

struct SByte2
{
char j; // 偏移量0
double d; // 偏移量8~15，由于1不能整除8，故先填充1~7
int a; // 偏移量16~19
};
sizeof(SByte2); // = 24，为了凑成8的倍数，填充20~23

F. C语言内存对齐问题.

为了有助于加快计算机的取数速度，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。

字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有
需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一
个成员之后加上填充字节（trailing padding）。

你这里struct的首地址要能被double的8字节整除，

1. char占1字节

2. int要被此时的地址整除，那么需要补上3字节，所以这里一共该是8字节

3. short2字节的，一共10字节，不满足3），不能整除int，故添加2字节

4. 最后是double 8字节，这里地址应该是首地址+12不能被8整除，所以+4字节。最后一共24B！

   问题解决求采纳！

G. c#中内存对齐是怎么回事

有虚函数的话就有虚表，虚表保存虚函数地址，一个地址占用的长度根据编译器不同有可能不同，vs里面是8个字节，在devc++里面是4个字节。类和结构体的对齐方式相同，有两条规则1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。2、结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行下面是我收集的关于内存对齐的一篇很好的文章：在最近的项目中，我们涉及到了“内存对齐”技术。对于大部分程序员来说，“内存对齐”对他们来说都应该是“透明的”。“内存对齐”应该是编译器的 “管辖范围”。编译器为程序中的每个“数据单元”安排在适当的位置上。但是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值的大小将不产生任何效果。三、试验我们通过一系列例子的详细说明来证明这个规则吧!我试验用的编译器包括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()成员总大小=82) 整体对齐整体对齐系数 = 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()成员总大小=92) 整体对齐整体对齐系数 = 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()成员总大小=92) 整体对齐整体对齐系数 = 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()成员总大小=92) 整体对齐整体对齐系数 = 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()成员总大小=92) 整体对齐整体对齐系数 = min((max(int,short,char), 16) = 4整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 12 /* 12%4=0 */四、结论8字节和16字节对齐试验证明了“规则”的第3点：“当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果”。另外内存对齐是个很复杂的东西，上面所说的在有些时候也可能不正确。呵呵^_^[注1]什么是“圆整”？举例说明：如上面的8字节对齐中的“整体对齐”，整体大小=9 按 4 圆整 = 12圆整的过程：从9开始每次加一，看是否能被4整除，这里9，10，11均不能被4整除，到12时可以，则圆整结束。

H. 内存对齐的详细解释

大部分的参考资料都是如是说的：
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值的大小将不产生任何效果。
Win32平台下的微软C编译器(cl.exefor 80×86)的对齐策略：
1)结构体变量的首地址是其最长基本类型成员的整数倍；
备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能是该基本数据类型的整倍的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。
2)结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
备注:为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。
3)结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节（trailing padding）。
备注：结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充几个字节以达到本条要求。
4) 结构体内类型相同的连续元素将在连续的空间内，和数组一样。
5) 如果结构体内存在长度大于处理器位数的元素，那么就以处理器的倍数为对齐单位；否则，如果结构体内的元素的长度都小于处理器的倍数的时候，便以结构体里面最长的数据元素为对齐单位。 我们通过一系列例子的详细说明来证明这个规则吧!
我试验用的编译器包括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[6];
};
#pragma pack(n)
首先我们首先确认在试验平台上的各个类型的size，经验证两个编译器的输出均为：
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
我们的试验过程如下：通过#pragma pack(n)改变“对齐系数”，然后察看sizeof(struct test_t)的值。
1、1字节对齐(#pragma pack(1))
输出结果：sizeof(struct test_t) = 13[两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(1)
struct test_t {
int a; /* int型，长度4 > 1 按1对齐；起始offset=0 0%1=0；存放位置区间[0,3] */
char b; /* char型，长度1 = 1 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* short型，长度2 > 1 按1对齐；起始offset=5 5%1=0；存放位置区间[5,6] */
char d[6]; /* char型，长度1 = 1 按1对齐；起始offset=7 7%1=0；存放位置区间[7,C] */
};/*char d[6]要看成6个char型变量*/
#pragma pack()
成员总大小=13
2) 整体对齐
整体对齐系数 = min((max(int,short,char), 1) = 1
整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 13 /*13%1=0*/ [注1]
2、2字节对齐(#pragma pack(2))
输出结果：sizeof(struct test_t) = 14 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(2)
struct test_t {
int a; /* int型，长度4 > 2 按2对齐；起始offset=0 0%2=0；存放位置区间[0,3] */
char b; /* char型，长度1 < 2 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* short型，长度2 = 2 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d[6]; /* char型，长度1 < 2 按1对齐；起始offset=8 8%1=0；存放位置区间[8,D] */
};
#pragma pack()
成员总大小=14
2) 整体对齐
整体对齐系数 = min((max(int,short,char), 2) = 2
整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 14 /* 14%2=0 */
3、4字节对齐(#pragma pack(4))
输出结果：sizeof(struct test_t) = 16 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(4)
struct test_t {
int a; /* int型，长度4 = 4 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b; /* char型，长度1 < 4 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /*short型， 长度2 < 4 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d[6]; /* char型，长度1 < 4 按1对齐；起始offset=8 8%1=0；存放位置区间[8,D] */
};
#pragma pack()
成员总大小=14
2) 整体对齐
整体对齐系数 = min((max(int,short,char), 4) = 4
整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 16 /*16%4=0*/
4、8字节对齐(#pragma pack(8))
输出结果：sizeof(struct test_t) = 16 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(8)
struct test_t {
int a; /* int型，长度4 < 8 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b; /* char型，长度1 < 8 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* short型，长度2 < 8 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d[6]; /* char型，长度1 < 8 按1对齐；起始offset=8 8%1=0；存放位置区间[8,D] */
};
#pragma pack()
成员总大小=14
2) 整体对齐
整体对齐系数 = min((max(int,short,char), 8) = 4
整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 16 /*16%4=0*/
5、16字节对齐(#pragma pack(16))
输出结果：sizeof(struct test_t) = 16 [两个编译器输出一致]
分析过程：
1) 成员数据对齐
#pragma pack(16)
struct test_t {
int a; /* int型，长度4 < 16 按4对齐；起始offset=0 0%4=0；存放位置区间[0,3] */
char b; /* char型，长度1 < 16 按1对齐；起始offset=4 4%1=0；存放位置区间[4] */
short c; /* short型，长度2 < 16 按2对齐；起始offset=6 6%2=0；存放位置区间[6,7] */
char d[6]; /* char型，长度1 < 16 按1对齐；起始offset=8 8%1=0；存放位置区间[8,D] */
};
#pragma pack()
成员总大小=14
2) 整体对齐
整体对齐系数 = min((max(int,short,char), 16) = 4
整体大小(size)=$(成员总大小) 按 $(整体对齐系数) 圆整 = 16 /*16%4=0*/ 8字节和16字节对齐试验证明了“规则”的第3点：“当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果”。另外内存对齐是个很复杂的东西，读者不妨把上述结构体中加个double型成员进去练习一下，上面所说的在有些时候也可能不正确。呵呵^_^
[注1]
什么是“圆整”？
举例说明：如上面的8字节对齐中的“整体对齐”，整体大小=9 按 4 圆整 = 12
圆整的过程：从9开始每次加一，看是否能被4整除，这里9，10，11均不能被4整除，到12时可以，则圆整结束。
上面文字表述太不直观了，鄙人给段代码直观的体现出来，代码如下：
#pragma pack(4) /* n = 1, 2, 4, 8, 16 */struct test_t{int a;char b;short c;char d[6];}ttt;void print_hex_data(char *info, char *data, int len){int i;dbg_printf(%s: , info);for(i = 0; i < len; i++){dbg_printf(%02x , (unsigned char)data[i]);if (0 == ((i+1) % 32))dbg_printf( );}dbg_printf( );}int main(){ttt.a = 0x1a2a3a4a;ttt.b = 0x1b;ttt.c = 0x1c2c;char *s = 123456;memcpy(ttt.d, s, 6);print_hex_data(struct_data, (char *)&ttt, sizeof(struct test_t));return 0;}
#pragma pack(1)的结果：
4a 3a 2a 1a 1b 2c 1c 31 32 33 34 35 36
#pragma pack(2)的结果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36
#pragma pack(4)的结果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(8)的结果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(16)的结果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00