一共有3篇：
第一篇：
转自：http://blog.csdn.net/soloist/article/details/213717
当在C中定义了一个结构类型时，它的大小是否等于各字段(field)大小之和？编译器将如何在内存中放置这些字段？ANSI C对结构体的内存布局有什么要求？而我们的程序又能否依赖这种布局？这些问题或许对不少朋友来说还有点模糊，那么本文就试着探究它们背后的秘密。
首先，至少有一点可以肯定，那就是ANSI C保证结构体中各字段在内存中出现的位置是随它们的声明顺序依次递增的，并且第一个字段的首地址等于整个结构体实例的首地址。比如有这样一个结构体：
struct vector{int x,y,z;} s;
int
*p,*q,*r;
struct vector *ps;
p =
&s.x;
q = &s.y;
r = &s.z;
ps =
&s;
assert(p < q);
assert(p < r);
assert(q <
r);
assert((int*)ps == p);
//
上述断言一定不会失败
这时，有朋友可能会问:"标准是否规定相邻字段在内存中也相邻?"。 唔，对不起，ANSI C没有做出保证，你的程序在任何时候都不应该依赖这个假设。那这是否意味着我们永远无法勾勒出一幅更清晰更精确的结构体内存布局图？哦，当然不是。不过先让我们从这个问题中暂时抽身，关注一下另一个重要问题————内存对齐。
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。当一种类型S的对齐模数与另一种类型T的对齐模数的比值是大于1的整数，我们就称类型S的对齐要求比T强(严格)，而称T比S弱(宽松)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。某些处理器在数据不满足对齐要求的情况下可能会出错，但是Intel的IA32架构的处理器则不管数据是否对齐都能正确工作。不过Intel奉劝大家，如果想提升性能，那么所有的程序数据都应该尽可能地对齐。Win32平台下的微软C编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小，即sizeof(T)。比如对于double类型(8字节)，就要求该类型数据的地址总是8的倍数，而char类型数据(1字节)则可以从任何一个地址开始。Linux下的GCC奉行的是另外一套规则(在资料中查得，并未验证，如错误请指正):任何2字节大小(包括单字节吗?)的数据类型(比如short)的对齐模数是2，而其它所有超过2字节的数据类型(比如long,double)都以4为对齐模数。
现在回到我们关心的struct上来。ANSI C规定一种结构类型的大小是它所有字段的大小以及字段之间或字段尾部的填充区大小之和。嗯？填充区？对，这就是为了使结构体字段满足内存对齐要求而额外分配给结构体的空间。那么结构体本身有什么对齐要求吗？有的，ANSI C标准规定结构体类型的对齐要求不能比它所有字段中要求最严格的那个宽松，可以更严格(但此非强制要求，VC7.1就仅仅是让它们一样严格)。我们来看一个例子(以下所有试验的环境是Intel Celeron 2.4G + WIN2000 PRO + vc7.1，内存对齐编译选项是"默认"，即不指定/Zp与/pack选项):
typedef struct ms1
{
char a;
int
b;
} MS1;
假设MS1按如下方式内存布局(本文所有示意图中的内存地址从左至右递增):
_____________________________
|
|
|
| a
|
b
|
|
|
|
+---------------------------+
Bytes:
1
4
因为MS1中有最强对齐要求的是b字段(int)，所以根据编译器的对齐规则以及ANSI C标准，MS1对象的首地址一定是4(int类型的对齐模数)的倍数。那么上述内存布局中的b字段能满足int类型的对齐要求吗？嗯，当然不能。如果你是编译器，你会如何巧妙安排来满足CPU的癖好呢？呵呵，经过1毫秒的艰苦思考，你一定得出了如下的方案：
_______________________________________
|
|///////////|
|
| a
|//padding//|
b
|
|
|///////////|
|
+-------------------------------------+
Bytes:
1
3
4
这个方案在a与b之间多分配了3个填充(padding)字节，这样当整个struct对象首地址满足4字节的对齐要求时，b字段也一定能满足int型的4字节对齐规定。那么sizeof(MS1)显然就应该是8，而b字段相对于结构体首地址的偏移就是4。非常好理解，对吗？现在我们把MS1中的字段交换一下顺序:
typedef struct ms2
{
int a;
char
b;
} MS2;
或许你认为MS2比MS1的情况要简单，它的布局应该就是
_______________________
|
| |
| a |
b |
|
| |
+---------------------+
Bytes:
4 1
因为MS2对象同样要满足4字节对齐规定，而此时a的地址与结构体的首地址相等，所以它一定也是4字节对齐。嗯，分析得有道理，可是却不全面。让我们来考虑一下定义一个MS2类型的数组会出现什么问题。C标准保证，任何类型(包括自定义结构类型)的数组所占空间的大小一定等于一个单独的该类型数据的大小乘以数组元素的个数。换句话说，数组各元素之间不会有空隙。按照上面的方案，一个MS2数组array的布局就是:
|<- array[1] ->|<- array[2] ->|<- array[3] .....
__________________________________________________________
|
|
|
| |
|
a | b
| a
| b
|.............
|
|
|
|
|
+----------------------------------------------------------
Bytes:
4
1
4 1
当数组首地址是4字节对齐时，array[1].a也是4字节对齐，可是array[2].a呢？array[3].a ....呢？可见这种方案在定义结构体数组时无法让数组中所有元素的字段都满足对齐规定，必须修改成如下形式:
___________________________________
|
|
|///////////|
|
a | b
|//padding//|
|
|
|///////////|
+---------------------------------+
Bytes:
4
1 3
现在无论是定义一个单独的MS2变量还是MS2数组，均能保证所有元素的所有字段都满足对齐规定。那么sizeof(MS2)仍然是8，而a的偏移为0，b的偏移是4。
好的，现在你已经掌握了结构体内存布局的基本准则，尝试分析一个稍微复杂点的类型吧。
typedef struct ms3
{
char a;
short
b;
double c;
} MS3;
我想你一定能得出如下正确的布局图:
padding
|
_____v_________________________________
| |/|
|/////////|
|
| a |/| b
|/padding/|
c |
| |/|
|/////////|
|
+-------------------------------------+
Bytes: 1 1
2
4
8
sizeof(short)等于2，b字段应从偶数地址开始，所以a的后面填充一个字节，而sizeof(double)等于8，c字段要从8倍数地址开始，前面的a、b字段加上填充字节已经有4
bytes，所以b后面再填充4个字节就可以保证c字段的对齐要求了。sizeof(MS3)等于16，b的偏移是2，c的偏移是8。接着看看结构体中字段还是结构类型的情况:
typedef struct ms4
{
char a;
MS3
b;
} MS4;
MS3中内存要求最严格的字段是c，那么MS3类型数据的对齐模数就与double的一致(为8)，a字段后面应填充7个字节，因此MS4的布局应该是:
_______________________________________
|
|///////////|
|
| a
|//padding//|
b
|
|
|///////////|
|
+-------------------------------------+
Bytes:
1
7
16
显然，sizeof(MS4)等于24，b的偏移等于8。
在实际开发中，我们可以通过指定/Zp编译选项来更改编译器的对齐规则。比如指定/Zpn(VC7.1中n可以是1、2、4、8、16)就是告诉编译器最大对齐模数是n。在这种情况下，所有小于等于n字节的基本数据类型的对齐规则与默认的一样，但是大于n个字节的数据类型的对齐模数被限制为n。事实上，VC7.1的默认对齐选项就相当于/Zp8。仔细看看MSDN对这个选项的描述，会发现它郑重告诫了程序员不要在MIPS和Alpha平台上用/Zp1和/Zp2选项，也不要在16位平台上指定/Zp4和/Zp8(想想为什么？)。改变编译器的对齐选项，对照程序运行结果重新分析上面4种结构体的内存布局将是一个很好的复习。
到了这里，我们可以回答本文提出的最后一个问题了。结构体的内存布局依赖于CPU、操作系统、编译器及编译时的对齐选项，而你的程序可能需要运行在多种平台上，你的源代码可能要被不同的人用不同的编译器编译(试想你为别人提供一个开放源码的库)，那么除非绝对必需，否则你的程序永远也不要依赖这些诡异的内存布局。顺便说一下，如果一个程序中的两个模块是用不同的对齐选项分别编译的，那么它很可能会产生一些非常微妙的错误。如果你的程序确实有很难理解的行为，不防仔细检查一下各个模块的编译选项。
思考题:请分析下面几种结构体在你的平台上的内存布局，并试着寻找一种合理安排字段声明顺序的方法以尽量节省内存空间。
A. struct P1 { int a; char b; int c;
char d; };
B. struct
P2 { int a; char b; char c; int d; };
C. struct P3 { short a[3]; char b[3];
};
D. struct P4 { short a[3]; char *b[3];
};
E. struct P5 { struct P2 *a; char b; struct P1
a[2]; };
参考资料:
【1】《深入理解计算机系统(修订版)》，
(著)Randal E.Bryant; David
O‘Hallaron，
(译)龚奕利
雷迎春，
中国电力出版社，2004
【2】《C: A
Reference Manual》(影印版)，
(著)Samuel P.Harbison; Guy
L.Steele，
人民邮电出版社，2003
第二篇：浅谈VC中的字节对齐
转自：http://blog.csdn.net/yunyun1886358/article/details/5651652
前几天时，在公司和同事说到了字节对齐，一直对这个概念比较模糊，只是在《程序员面试宝典》中看到过简单的描述和一些面试题。后来在论坛中有看到有朋友在询问字节对齐的相关问题，自己也答不上来，觉得应该研究一下，所以就有了这一篇博文，是对学习的一个总结，也是对成长轨迹的一个记录。
字节对齐，又叫内存对齐，个人理解就是一种C++中的类型在内存中空间分配策略。每一种类型存储的起始地址，都要求是一个对齐模数(alignment modulus)的整数倍。问题来了，为什么要有这种策略？计算中内存中的数据就是一个一个的字节（byte），直接按照一个字节一个字节存储就得了，为什么还要那么麻烦。把问题想简单了。
各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问 一个没有进行对齐的变量的时候会发生错误，那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对 数据存放进行对齐，会在存取效率上带来损失。
计算机CPU一次处理可以处理多个字节，就拿32位系统来说，CPU一次可以处理32bit的数据，也就是4个字节。比如有些平台每次读都是从偶地址开始，假设有一个int型数据，存放在内存地址0x1的位置。CPU要读取这个int数据，并且从地址0x0开始读取数据。一次读取4字节，那么这个int型还有一个字节没有读到，就得再读取一次剩下的那一个字节，并且还要进行位操作，把两次读取的数据合并为一个int型数据。两个字--麻烦，效率太低了。那怎么办呢？为了提高效率，干脆在存储的时候把这个int数据放在内存地址0x4的位置，0x1、0x2、0x3的位置都空着，CPU直接从0x4取数据，只需一次就取到了这个数据，还不用进行位操作。就是拿空间换时间，没办法，谁让现在的存内存越来越大了呢？
下面一些知识的总结，部分来自互联网，感谢那些为C++奋斗的兄弟。
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4的倍数，这就是所谓的字节对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。当一种类型S的对齐模数与另一种类型T的对齐模数的比值是大于1的整数，我们就称类型S的对齐要求比T强(严格)，而称T比S弱(宽松)。下面来讨论4种不同类型的对齐模数：
char 1
short 2
int 4
float 4
double 8
等同于其成员中最大的自身对齐模数
我们给编译器指定的对齐模数（在VC中使用指令：#pragma pack(n)，如果不指定，在VS2010默认为8）
指定对齐模数与类型自身对齐模数的较小的值，就是实际生效的对齐模数。
例如：
1 struct alignment 2 { 3 char ch; // 自身对齐模数1，指定对齐模数8，有效对齐模数1 4 int i; // 自身对齐模数4，指定对齐模数8，有效对齐模数4 5 short sht; // 自身对齐模数2，指定对齐模数8，有效对齐模数2 6 }; // 自身对齐模数4，指定对齐模数8，有效对齐模数4
在上例中，假设起始地址0x0，那么ch的地址为离0x0最近的且能被ch的有效对齐模数整除的地址，那么就是0x0；以此类推，i的地址为0x4，sht的地址为0x8，alignment的地址与ch的地址一致。
作用：指定结构体、联合以及类成员的packing alignment;
语法：#pragma pack( [show] | [push | pop] [, identifier], n )
说明：
语法具体分析：
使用示例：
1 #include<iostream> 2 3 using namespace std; 4 5 #pragma pack(show) // Output中输出如下信息：warning C4810: value of pragma pack(show) == 8 6 #pragma pack(push, alignmentDEfault) // 使用标识符alignmentDEfault压栈默认字节对齐模数 7 8 #pragma pack(1) // 将对齐模数设置为1 9 #pragma pack(show) 10 #pragma pack(push, alignment1) // 使用标识符alignment1压栈默认字节对齐模数 11 struct alignment1 12 { 13 char ch; 14 int i; 15 short sht; 16 }; 17 18 #pragma pack(2) // 将对齐模数设置为2 19 #pragma pack(show) 20 #pragma pack(push, alignment2) // 使用标识符alignment2压栈默认字节对齐模数 21 struct alignment2 22 { 23 char ch; 24 int i; 25 short sht; 26 }; 27 28 #pragma pack(push, alignment8, 8) // 使用标识符alignment2压栈默认字节对齐模数 29 #pragma pack(show) 30 struct alignment8 31 { 32 char ch; 33 int i; 34 short sht; 35 }; 36 37 #pragma pack(pop, alignmentDEfault) // 将标号alignmentDEfault对应的字节对齐模数弹出栈 38 #pragma pack(show) 39 struct alignmentDefault 40 { 41 char ch; 42 int i; 43 short sht; 44 }; 45 46 int main() 47 { 48 alignment1 align1; 49 cout << (int)&align1.i - (int)&align1.ch << endl; // 输出1 50 cout << (int)&align1.sht - (int)&align1.i << endl; // 输出4 51 52 alignment2 align2; 53 cout << (int)&align2.i - (int)&align2.ch << endl; // 输出2 54 cout << (int)&align2.sht - (int)&align2.i << endl; // 输出4 55 56 alignment8 align8; 57 cout << (int)&align8.i - (int)&align8.ch << endl; // 输出4 58 cout << (int)&align8.sht - (int)&align8.i << endl; // 输出4 59 60 alignmentDefault alignmentD; 61 cout << (int)&alignmentD.i - (int)&alignmentD.ch << endl; // 输出4 62 cout << (int)&alignmentD.sht - (int)&alignmentD.i << endl; // 输出4 63 }
字节对齐规则影响着struct和class的内存占用。来看一个例子：
1 #include <iostream> 2 3 #pragma pack(8) 4 struct example1 5 { 6 short a; 7 long b; 8 }; 9 10 struct example2 11 { 12 char c; 13 example1 struct1; 14 short e; 15 }; 16 #pragma pack() 17 18 int main(int argc, char* argv[]) 19 { 20 example2 struct2; 21 22 cout << sizeof(example1) << endl; 23 cout << sizeof(example2) << endl; 24 cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2) << endl; 25 26 return 0; 27 }
程序中第2行#pragma pack (8)虽然指定了对齐模数为8，但是由于struct
example1中的成员最大size为4（long变量size为4），故struct example1仍然按4字节对齐，struct
example1的size为8，即第22行的输出结果；
struct example2中包含了struct
example1，其本身包含的简单数据成员的最大size为2（short变量e），但是因为其包含了struct example1，而struct
example1中的最大成员size为4，struct example2也应以4对齐，#pragma pack (8)中指定的对齐对struct
example2也不起作用，故23行的输出结果为16；
由于struct
example2中的成员以4为单位对界，故其char变量c后应补充3个空，其后才是成员struct1的内存空间，24行的输出结果为4。
如果在编程的时候要考虑节约空间的话,那么我们只需要假定结构的首地址是0,然后各个变量按照上面的原则进行排列即可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽量减少中间的填补空间.还有一种就是为了以空间换取时间的效率,我们显示的进行填补空间进行对齐,比如:有一种使用空间换时间做法是显式的插入reserved成员：
struct
A{
char a;
char
reserved[3];//使用空间换时间
int
b;
}
reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.
代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。例如：
unsigned int i =
0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;
p=&i;
*p=0x00;
p1=(unsigned short
*)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐.
如果出现对齐或者赋值问题首先查看
第三篇：谈谈关于内存对齐与补齐
转自：http://blog.csdn.net/cyousui/article/details/17655051
首先我们先看看下面的C语言的结构体：
以上这个结构体占用内存多少空间呢？也许你会说，这个简单，计算每个类型的大小，将它们相加就行了，以32为平台为例，int类型占4字节，char占用1字节，所以：4 + 3 + 4 = 11，那么这个结构体一共占用11字节空间。好吧，那么我们就用实践来证明是否正确，我们用sizeof运算符来求出这个结构体占用内存空间大小，sizeof(MemAlign)，出乎意料的是，结果居然为12？看来我们错了？当然不是，而是这个结构体被优化了，这个优化有个另外一个名字叫“对齐”，那么这个对齐到底做了什么样的优化呢，听我慢慢解释，再解释之前我们先看一个图，图如下：
相信学过汇编的朋友都很熟悉这张图，这张图就是CPU与内存如何进行数据交换的模型，其中，左边蓝色的方框是CPU，右边绿色的方框是内存，内存上面的0～3是内存地址。这里我们这张图是以32位CPU作为代表，我们都知道，32位CPU是以双字（DWORD）为单位进行数据传输的，也正因为这点，造成了另外一个问题，那么这个问题是什么呢？这个问题就是，既然32位CPU以双字进行数据传输，那么，如果我们的数据只有8位或16位数据的时候，是不是CPU就按照我们数据的位数来进行数据传输呢？其答案是否定的，如果这样会使得CPU硬件变的更复杂，所以32位CPU传输数据无论是8位或16位都是以双字进行数据传输。那么也罢，8位或16位一样可以传输，但是，事情并非像我们想象的那么简单，比如，一个int类型4字节的数据如果放在上图内存地址1开始的位置，那么这个数据占用的内存地址为1～4，那么这个数据就被分为了2个部分，一个部分在地址0～3中，另外一部分在地址4～7中，又由于32位CPU以双字进行传输，所以，CPU会分2次进行读取，一次先读取地址0～3中内容，再一次读取地址4～7中数据，最后CPU提取并组合出正确的int类型数据，舍弃掉无关数据。那么反过来，如果我们把这个int类型4字节的数据放在上图从地址0开始的位置会怎样呢？读到这里，也许你明白了，CPU只要进行一次读取就可以得到这个int类型数据了。没错，就是这样，这次CPU只用了一个周期就得到了数据，由此可见，对内存数据的摆放是多么重要啊，摆放正确位置可以减少CPU的使用资源。
那么，内存对齐有哪些原则呢？我总结了一下大致分为三条：
第一条：第一个成员的首地址为0
第二条：每个成员的首地址是自身大小的整数倍
第二条补充：以4字节对齐为例，如果自身大小大于4字节，都以4字节整数倍为基准对齐。
第三条：最后以结构总体对齐。
第三条补充：以4字节对齐为例，取结构体中最大成员类型倍数，如果超过4字节，都以4字节整数倍为基准对齐。（其中这一条还有个名字叫：“补齐”，补齐的目的就是多个结构变量挨着摆放的时候也满足对齐的要求。）
上述的三原则听起来还是比较抽象，那么接下来我们通过一个例子来加深对内存对齐概念的理解，下面是一个结构体，我们动手算出下面结构体一共占用多少内存？假设我们以32位平台并且以4字节对齐方式：
下图为对齐后结构如下：
我们就以这个图来讲解是如何对齐的：
第一个成员（char
a[18]）：首先，假设我们把它放到内存开始地址为0的位置，由于第一个成员占18个字节，所以第一个成员占用内存地址范围为0～18。
第二个成员（double
b）：由于double类型占8字节，又因为8字节大于4字节，所以就以4字节对齐为基准。由于第一个成员结束地址为18，那么地址18并不是4的整数倍，我们需要再加2个字节，也就是从地址20开始摆放第二个成员。
第三个成员（char
c）：由于char类型占1字节，任意地址是1字节的整数倍，所以我们就直接将其摆放到紧接第二个成员之后即可。
第四个成员（int
d）：由于int类型占4字节，但是地址29并不是4的整数倍，所以我们需要再加3个字节，也就是从地址32开始摆放这个成员。
第五个成员（short
e）：由于short类型占2字节，地址36正好是2的整数倍，这样我们就可以直接摆放，无需填充字节,紧跟其后即可。
这样我们内存对齐就完成了。但是离成功还差那么一步，那是什么呢？对，是对整个结构体补齐，接下来我们就补齐整个结构体。那么，先让我们回顾一下补齐的原则：“以4字节对齐为例，取结构体中最大成员类型倍数，如果超过4字节，都以4字节整数倍为基准对齐。”在这个结构体中最大类型为double类型（占8字节），又由于8字节大于4字
节，所以我们还是以4字节补齐为基准，整个结构体结束地址为38，而地址38并不是4的整数倍，所以我们还需要加额外2个字节来填充结构体，如下图红色的就是补齐出来的空间：
到此为止，我们内存对齐与补齐就完毕了！接下来我们用实验来证明真理，程序如下：
程序运行过程中，查看内存如下：
其中，各种颜色带下划线的代表各个成员变量，蓝色方框的代表为内存对齐时候填补的多余字节，由于这里看不到补齐效果，我们接下来看下图，下图篮框包围的字节就是与上图的交集以外的部分就是补齐所填充的字节。
在最后，我在谈一谈关于补齐的作用，补齐其实就是为了让这个结构体定义的数组变量时候，数组内部，也同样满足内存对齐的要求，为了更好的理解这点，我做了一个跟本例子相对照的图：
原文：http://www.cnblogs.com/kira2will/p/3655094.html
