编译器为什么要替我们内存对齐？
学了计算机组成原理，了解了内存的基本单元是一个字节，内存可以随机寻址，于是乎我天真的认为内存就是一个字节型的容器，基本单位是单个字节。
Figure 1. 我眼中的内存空间布局
悲剧的是，内存读写的真正访问者cpu不是这么想的。cpu是根据内存访问粒度（memory access granularity，下文简写成MAG）来读取内存，MAG就是cpu一次内存访问操作的数据量，具体数值依赖于特定的平台，一般是2byte、4byte、8byte。
Figure 2. cpu眼中的内存空间布局
因此，程序员和cpu看待内存空间布局是存在差异的。唉，既不能过多的苛刻程序员，又要让cpu舒服，怎么办呢？只好让编译器来对我们的代码进行隐式的内存对齐（当然它能做的只是帮程序中的数据进行内存对齐，至于直接用指针去访问内存，它是不会管的）。向开发编译器的大大们致敬！
内存对齐的好处
下面用一个小实例来剖析内存对齐的好处：很简单，在32位的机器下，分别访问一个内存对齐的地址空间（从地址0开始）和一个没有对齐的地址空间（从地址1开始），读取四个字节到cpu的寄存器中，比较两者的读取过程。
Case1：内存访问粒度为1个字节（cpu眼中的内存模型等价于程序员眼中的内存模型）：
Figure 3. MAG=1
Result：读取4个字节，两者都需要进行4次内存访问操作。打平，在MAG=1的情况下不需要考虑内存对齐。
Case2：内存访问粒度为2个字节：
Figure 4. MAG=2
Result：读取4个字节，左边的（内存对齐地址）只需要进行2次内存访问操作，右边的需要进行3次内存访问操作+附加操作（见下文）。内存对齐地址取胜！
Case3：内存访问粒度为4个字节：
Figure 5. MAG=4
Result：读取4个字节，左边的只需要进行1次内存访问操作，右边的需要进行2次内存访问操作+附加操作。内存对齐地址再次取胜！
Conclusion：
内存对齐地址vs没有内存对齐的地址，在三种不同的内存访问粒度下，取得了2胜一平的完胜战绩。对于32位的机器，实际的内存访问粒度是4个字节，原因如下：
- 每一次内存访问操作需要一个常量开销；
- 在数据量一定的情况下，减少内存访问操作，能提高程序运行性能；
- 增大内存访问粒度（当然不超过数据总线的带宽），能减少内存访问操作（从上面的实例就能够看出来）；
一句话，内存对齐确实可以提高程序性能。
cpu如何处理没有内存对齐的数据访问？
继续分析上面那个实例，在内存访问粒度为2、从地址1开始读取四个字节的cpu处理过程（硬件方式）：
- 读取数据所在的第一块内存空间（0-1），移除多余字节（0）；
- 读取数据所在的第二块内存空间（2-3）；
- 读取数据所在的第三块内存空间（4-5），移除多余字节（5）；
- 把三块数据拼接起来（1-4），放入寄存器中。
访问一块相同大小的数据，内存对齐的优势是多么的巨大！
如果cpu能这么来处理，也只不过是影响了我们程序的运行性能，至少还是能运行的！悲剧的是，以前的cpu并没有这么“勤快”，遇到没有内存对齐的数据访问，它会直接抛出一个异常：操作系统可能会响应这个异常，用软件的方式来处理，性能只会更差；或者程序直接崩溃掉。一句话，内存对齐的代码确实具有更高的可移植性！
结构体在内存中的对齐方式
个人总结：
结构体默认的对齐模数不是sizeof（结构体），而是结构体成员中最大的对齐模数。例如
struct A{
int a；//默认对齐模数k(int)=sizeof(int)=4
char b;//默认对齐模数k(char)=sizeof(char)=1
struct B d；//默认对齐模数k(struct B)为B成员最大的对齐模数即k(double)=8
}；//A默认对齐模数k(struct A)为A成员最大的对齐模数k(struct B)=8
struct B{
int a；//默认对齐模数k(int)=sizeof(int)=4
char b;//默认对齐模数k(char)=sizeof(char)=1
double c；//默认对齐模数k(double)=sizeof(double)=8
short ；//默认对齐模数k(short)=sizeof(short)=2
}；//B默认对齐模数k(struct B)为B成员最大的对齐模数即k(double)=8
由上面的两个结构体可以看出 ：
基本数据类型的默认对齐模数k=sizeof(type);
复杂数据类型如结构体，其默认对齐模数k=max{各个成员的默认对齐模数}；
存储规则：
1.当系统指定了对齐模数k时，不同类型的数据按照k(m)=min{默认的对齐模数k，系统指定的k}模数来存储数据；
2.该类型的数据起始地址add%k(m)=0;为什么要这样满足这个条件呢？
其原因是各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那 么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数 据。显然在读取效率上下降很多。
3.该类型的数据大小size%k(m)=0，不足的要补齐(结构体中经常需要补齐);为什么要这样满足这个条件呢？
因为考虑到该类型的数组，按照数组的定义,数组中所有元素都是紧挨着的。
结构体内存分配问题(转)
1）sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用。
（2）终于搞懂struct结构体内存分配问题了，结构体中各个成员字节对齐遵循以下几个原则：
1.结构体每个成员相对于结构体首地址的偏移量（offset）都是（这个）成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
例如有以下一个结构体
struct ex {
int i;
char t;
int n;
}
第1个成员偏移量为0，是int型成员大小4（假设这太机器的整型长度占4个字节）的整数倍。
第2个成员 t 为char型，他的大小为1，首先假设在成员i和t之间没有填充字节，由于i是整型，占4个字节那么在没有填充之前，第2个成员t相对于结构体的偏移量为4，他是t成员大小1的4倍，符合此条件，所以系统在给结构体第2个成员分配内存时，不会在i和t之间填充字节以到达对齐的目的。
当分配结构体第3个成员n时，首先发现是一个整型数据，大小为4，没有填充之前，n相对于结构体首地址偏移量为：前面2个成员+填充字节=5，所以当系统发现5不是4（成员大小）的整数倍时，会在成员t之后（或者说n之前）填充3个字节，以使n的偏移量到达8而成为4的整数倍。这样这个结构体占用内存情况暂时为4+1+3+4。
2.结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。
上面的结构体内存分配以后还要看是否满足此条件，假设在最末一个成员之后不需填充字节数，那么这个结构体的大小为12。而ex结构体中最宽基本类型成员为int，大小为4，12为4的整数倍，所以无须再在最末一个成员之后加上填充字节了。所以sizeof(ex)=12;
如果一个结构体如下所示struct ex1{
int i;
char t;
int n;
char add;
}
那么sizeof(ex1) =16;原因就是在最后一个成员之后填充了3个字节。
3.还有一个额外的条件：结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
4.对于结构体成员属性中包含结构体变量的复合型结构体再确定最宽基本类型成员时，应当包括复合类型成员的子成员。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。
5总结出一个公式：结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )
C/C++ 中已经提供了宏 offsetof 计算成员的偏移量。注意包含头文件：C 是 <stddef.h>，C++ 是 <cstddef>。
------------------------------------------------------------------------------------------------------------------------------------
由于程序运行时占用的内存过大，所以想办法给程序瘦身。
在调试中发现结构体占用的size竟然和预想的不一样，原来……
看看下面讲的吧，肯定会不枉此看哦！
1,比如:
struct{
short a1;
short a2;
short a3;
}A;
struct{
long a1;
short a2;
}B;
sizeof(A)=6, sizeof(B)=8,为什么？
注：sizeof(short)=2,sizeof(long)=4
因为:“成员对齐有一个重要的条件,即每个成员按自己的方式对齐.其对齐的规则是,每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里默认是8字节)中较小的一个对齐.并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节.”(引用)
结构体A中有3个short类型变量，各自以2字节对齐，结构体对齐参数按默认的8字节对齐，则a1,a2,a3都取2字节对齐，则sizeof(A)为6，其也是2的整数倍；
B中a1为4字节对齐，a2为2字节对齐，结构体默认对齐参数为8，则a1取4字节对齐，a2取2字节对齐，结构体大小6字节，6不为4的整数倍，补空字节，增到8时，符合所有条件，则sizeof(B)为8；
可以设置成对齐的
#pragma pack(1)
#pragma pack(push)
#pragma pack(1)
struct{
short a1;
short a2;
short a3;
}A;
struct{
long a1;
short a2;
}B;
#pragma pack(pop)
结果为sizeof( A)=6,sizeof( B)=6
************************
2,又如:
#pragma pack(8)
struct S1{
char a;
long b;
};
struct S2 {
char c;
struct S1 d;
long long e;
};
#pragma pack()
sizeof(S2)结果为24.
成员对齐有一个重要的条件,即每个成员分别对齐.即每个成员按自己的方式对齐.
也就是说上面虽然指定了按8字节对齐,但并不是所有的成员都是以8字节对齐.其对齐的规则是,每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(这里是8字节)中较小的一个对齐.并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节.
S1中,成员a是1字节默认按1字节对齐,指定对齐参数为8,这两个值中取1,a按1字节对齐;成员b是4个字节,默认是按4字节对齐,这时就按4字节对齐,所以sizeof(S1)应该为8;
S2 中,c和S1中的a一样,按1字节对齐,而d 是个结构,它是8个字节,它按什么对齐呢?对于结构来说,它的默认对齐方式就是它的所有成员使用的对齐参数中最大的一个,S1的就是4.所以,成员d就是按4字节对齐.成员e是8个字节,它是默认按8字节对齐,和指定的一样,所以它对到8字节的边界上,这时, 已经使用了12个字节了,所以又添加了4个字节的空,从第16个字节开始放置成员e.这时,长度为24,已经可以被8(成员e按8字节对齐)整除.这样, 一共使用了24个字节.
a b
S1的内存布局：1***, 1111,
c S1.a S1.b e
S2的内存布局：1***, 1***, 1111, ****11111111
这里有三点很重要:
1.每个成员分别按自己的方式对齐,并能最小化长度
2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度
3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐
补充一下,对于数组,比如:
char a[3];这种,它的对齐方式和分别写3个char是一样的.也就是说它还是按1个字节对齐.
如果写: typedef char Array3[3];
Array3这种类型的对齐方式还是按1个字节对齐,而不是按它的长度.
不论类型是什么,对齐的边界一定是1,2,4,8,16,32,64....中的一个.
字节对齐详解
一.为什么要对齐?
现代计算机中内存空间都是按照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;
};
现在已知32位机器上各种数据类型的长度如下:
char:1(有符号无符号同)
short:2(有符号无符号同)
int:4(有符号无符号同)
long:4(有符号无符号同)
float:4 double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值却是12
结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。
之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
char b;
int a;
short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。
后面我们再讲解#pragma pack()的作用.
三.编译器是按照什么样的原则进行对齐的?
先让我们看四个重要的基本概念：
1.数据类型自身的对齐值：
对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
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;其实如果就这一个就来说它已将满足字节对齐了, 因为它的起始地址是0,因此肯定是对齐的,之所以在后面补充2个字节,是因为编译器为了实现结构数组的存取效率,试想如果我们定义了一个结构B的数组,那 么第一个结构起始地址是0没有问题,但是第二个结构呢?按照数组的定义,数组中所有元素都是紧挨着的,如果我们不把结构的大小补充为4的整数倍,那么下一 个结构的起始地址将是0x0000A,这显然不能满足结构的地址对齐了,因此我们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其 自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只 是因为这些类型的长度已知了,所以他们的自身对齐值也就已知了.
同理,分析上面例子C：
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
char b;
int a;
short c;
};
#pragma 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.
四.如何修改编译器的默认对齐值?
1.在VC IDE中，可以这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。
2.在编码时，可以这样动态修改：#pragma pack .注意:是pragma而不是progma.
五.针对字节对齐,我们在编程中如何考虑?
如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照 类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做 法是显式的插入reserved成员：
struct A{
char a;
char reserved[3];//使用空间换时间
int b;
}
reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.
Over！更多内容，参照此文：https://www.ibm.com/developerworks/library/pa-dalign/
内存对齐的具体规则，参照此篇博客：http://blog.csdn.net/liu1064782986/article/details/7600979