关于内存对齐的总结

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

二、请看下面的结构：
struct MyStruct 
{ 
double dda1; 
char dda; 
int type 
}; 
对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求： 
sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 
但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？ 
其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。 
类型 
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） 
Char 
偏移量必须为sizeof(char)即1的倍数 
int 
偏移量必须为sizeof(int)即4的倍数 
float 
偏移量必须为sizeof(float)即4的倍数 
double 
偏移量必须为sizeof(double)即8的倍数 
short
偏移量必须为sizeof(short)即2的倍数 
各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。 
对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
这里面有四个概念值：
1)数据类型自身的对齐值：就是上面交代的基本数据类型的自身对齐值。

2)指定对齐值：#pragma pack (value)时的指定对齐值value。

3)结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。

4)数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中较小的那个值

下面用前面的例子来说明VC到底怎么样来存放结构的。 
struct MyStruct 
{ 
double dda1; 
char dda; 
int type 
}； 
为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用 sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof (int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(MyStruct)=8+1+ 3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。 
下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况： 
struct MyStruct 
{ 
char dda; 
double dda1;   
int type 
}； 
这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明） 
struct MyStruct 
{ 
char dda;      //偏移量为0，满足对齐方式，dda占用1个字节； 
double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8 
                    //的倍数，需要补足7个字节才能使偏移量变为8（满足对齐 
                   //方式），因此VC自动填充7个字节，dda1存放在偏移量为8 
                  //的地址上，它占用8个字节。 
int type；    //下一个可用的地址的偏移量为16，是sizeof(int)=4的倍 
           //数，满足int的对齐方式，所以不需要VC自动填充，type存 
           //放在偏移量为16的地址上，它占用4个字节。 
}；//所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构 
   //的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof 
   //(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为 
   //sizeof(double)=8的倍数。 
所以该结构总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。 
VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。 
VC 中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数； 
否则必须为n的倍数。下面举例说明其用法。 
#pragma pack(push) //保存对齐状态 
#pragma pack(4)//设定为4字节对齐 
struct test 
{ 
char m1; 
double m4; 
int m3; 
}; 
#pragma pack(pop)//恢复对齐状态 
以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为 m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。（请读者自己分析）
三、再看下面这个例子
#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的内存布局：11**,1111,
c S1.a S1.b d
S2的内存布局：1***,11**,1111,****11111111
这里有三点很重要:
1.每个成员分别按自己的方式对齐,并能最小化长度。
2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。
3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。
Win32平台下的微软 编译器(cl.exe for 80×86)的对齐策略： 
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除； 
备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能被该基本数据类型所整除的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。 
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）； 
备注:为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。 
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节（trailing padding）。 
备注：结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充几个字节以达到本条要求。
补：每个特定平台的编译器都有一个默认的自然对界n，也可以通过于编译命令#pragma pack(n)来指定该系数，其中n的值经测试只能是1，2和4. 每个数据成员按#pragma pack(n)中n指定的值和该数据成员自身长度中比较小的那个为初始值的倍数进行对齐。数据成员完成对齐后，结构体本身也要对齐，按照#pragma pack(n)中n的值和结构体数据成员中最长的长度中较小的那个为总长度的倍数进行对齐。
默认情况（n=4）
       struct st1 {
              char ch;//长度1<n，按1对齐,0%1=0,起始相对位置=0；存放区间[0]
              int num;//长度4=n，按4对齐， 4%4=0，起始相对位置=4；存放区间[4,7]
              long lv;//长度4=n,按4对齐，8%4=0，起始相对位置=8；存放区间[8,11]
       };
联系到结构体，因为结构体没有必要存储在内存的连续空间，所以不能使用运算符==和!=莱比较结构。
字是标准的存储单元，它用于在计算机中存储数据，通常是2个字节或4个字节。
再举一例：
Struct A{
   Char a;
   Short b;
}

Sizeof(struct A)=4，而不是8，因为char=1<n，所以占1字节，而short=2<4,所以在相对偏移量等于2的地方进行对齐。

给你举个例子，如下结构体成员的大小是a+b=1+4=5个字节，但是事实上结构体的大小是8，因为要字节对齐，就是说32位的机器 
//它的每个地址是4个字节，那如果有零头也会按4个字节算，这样方便取地址，程序如下： 
#include <stdio.h> 
struct A{ 
char a; 
int b; 
};
int main (){ 
A ab; 
printf("sizeof(A)=%d,sizoeof(a)=%d,sizoe(b)=%dn",sizeof(ab),sizeof(ab.a),sizeof(ab.b)); 
}
在没有程序中自定义对齐方式的情况下编译器一般默认对齐方式为4字节对齐、。 
之所以有内存对齐问题，我个人认为是为了提高程序执行效率。即牺牲空间节省时间。 
在这里，具体内存分配情况如下： 
struct header 
{ 
BYTE by; //占用1字节 
DWORD dw; //为了内存对齐他从第5个字节开始存储，并占用4个 
int flag; //从第9个字节开始存储，并占用4个 
}; 
如果想强制只使用类型所占空间的内存，那么使用如下语句 
#pragma pack(1)
sizeof(结构体)和内存对齐 
Oct 4th, 2007 by king
有的时候，在脑海中停顿了很久的“显而易见”的东西，其实根本上就是错误的。就拿下面的问题来看：
struct T 
{ 
char ch; 
int i ; 
}; 
使用sizeof(T)，将得到什么样的答案呢？要是以前，想都不用想，在32位机中，int是4个字节，char是1个字节，所以T一共是5个字节。实践出真知，在VC6中测试了下，答案确实8个字节。哎，反正受伤的总是我，我已经有点麻木了，还是老老实实的接受吧！为什么答案和自己想象的有出入呢？这里将引入内存对齐这个概念。
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。当一种类型S的对齐模数与另一种类型T的对齐模数的比值是大于1的整数，我们就称类型S的对齐要求比T强(严格)，而称T比S弱(宽松)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。某些处理器在数据不满足对齐要求的情况下可能会出错，但是Intel的IA32架构的处理器则不管数据是否对齐都能正确工作。不过Intel奉劝大家，如果想提升性能，那么所有的程序数据都应该尽可能地对齐。
ANSI C标准中并没有规定，相邻声明的变量在内存中一定要相邻。为了程序的高效性，内存对齐问题由编译器自行灵活处理，这样导致相邻的变量之间可能会有一些填充字节。对于基本数据类型(int char)，他们占用的内存空间在一个确定硬件系统下有个确定的值，所以，接下来我们只是考虑结构体成员内存分配情况。
Win32平台下的微软C编译器(cl.exe for 80×86)的对齐策略： 
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除； 
备注：编译器在给结构体开辟空间时，首先找到结构体中最宽的基本数据类型，然后寻找内存地址能被该基本数据类型所整除的位置，作为结构体的首地址。将这个最宽的基本数据类型的大小作为上面介绍的对齐模数。 
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）； 
备注:为结构体的一个成员开辟空间之前，编译器首先检查预开辟空间的首地址相对于结构体首地址的偏移是否是本成员的整数倍，若是，则存放本成员，反之，则在本成员和上一个成员之间填充一定的字节，以达到整数倍的要求，也就是将预开辟空间的首地址后移几个字节。 
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要，编译器会在最末一个成员之后加上填充字节（trailing padding）。 
备注：结构体总大小是包括填充字节，最后一个成员满足上面两条以外，还必须满足第三条，否则就必须在最后填充几个字节以达到本条要求。
根据以上准则，在windows下，使用VC编译器，sizeof(T)的大小为8个字节。
而在GNU GCC编译器中，遵循的准则有些区别，对齐模数不是像上面所述的那样，根据最宽的基本数据类型来定。在GCC中，对齐模数的准则是：对齐模数最大只能是4，也就是说，即使结构体中有double类型，对齐模数还是4，所以对齐模数只能是1，2，4。而且在上述的三条中，第2条里，offset必须是成员大小的整数倍，如果这个成员大小小于等于4则按照上述准则进行，但是如果大于4了，则结构体每个成员相对于结构体首地址的偏移量（offset）只能按照是4的整数倍来进行判断是否添加填充。 
看如下例子：
struct T 
{ 
char ch; 
double d ; 
}; 
那么在GCC下，sizeof(T)应该等于12个字节。
如果结构体中含有位域(bit-field)，那么VC中准则又要有所更改： 
1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止； 
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍； 
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式（不同位域字段存放在不同的位域类型字节中），Dev-C++和GCC都采取压缩方式； 
备注：当两字段类型不一样的时候，对于不压缩方式，例如：
struct N 
{ 
char c:2; 
int i:4; 
}; 
依然要满足不含位域结构体内存对齐准则第2条，i成员相对于结构体首地址的偏移应该是4的整数倍，所以c成员后要填充3个字节，然后再开辟4个字节的空间作为int型，其中4位用来存放i，所以上面结构体在VC中所占空间为8个字节；而对于采用压缩方式的编译器来说，遵循不含位域结构体内存对齐准则第2条，不同的是，如果填充的3个字节能容纳后面成员的位，则压缩到填充字节中，不能容纳，则要单独开辟空间，所以上面结构体N在GCC或者Dev-C++中所占空间应该是4个字节。
4) 如果位域字段之间穿插着非位域字段，则不进行压缩； 
备注： 
结构体
typedef struct 
{ 
char c:2; 
double i; 
int c2:4; 
}N3; 
在GCC下占据的空间为16字节，在VC下占据的空间应该是24个字节。 
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
ps:
对齐模数的选择只能是根据基本数据类型，所以对于结构体中嵌套结构体，只能考虑其拆分的基本数据类型。而对于对齐准则中的第2条，确是要将整个结构体看成是一个成员，成员大小按照该结构体根据对齐准则判断所得的大小。 
类对象在内存中存放的方式和结构体类似，这里就不再说明。需要指出的是，类对象的大小只是包括类中非静态成员变量所占的空间，如果有虚函数，那么再另外增加一个指针所占的空间即可。

关于内存对齐问题.
悬赏分：0 - 解决时间：2007-7-30 06:02
没弄明白内存对齐的方式. 
#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() 
为什么c要占用6,7单元而不是5,6单元呢.
问题补充：那是怎么保证第一个元素的内存地址都是在0位置的呢?
提问者： wm09323 - 魔法师 四级 最佳答案
pack(2) 就是要保证变量在2字节边界对齐，即每个变量的起始地址是2的倍数 
b存放在区间[4] ，区间〔5〕闲置不用
以此类推了，pack(4)就是4字节对齐。。。。
看错, 
#pragma pack(n)的作用你还没理解透
这个n的值可以为1, 2, 4, 8, 16，pack的原则是尽量使其在内存中和机器的自然字长相同，你的机器自然字长可能是2字也就是4字节，所以当n > 4时，字节数小于4的类型会被自动填充为4字节，大于4字节的才根据n的指定来填充，所以你那个类的内存排列方式应该是这样：
vptr: 4, int 4, double 16;
我考虑过是否是编译器优化的结果，但我看了下发现我的编译器优化是被关掉的，而且struct和clas的对齐方式是默认default，所以得出以上结论，仅供参考!