结构体字节对齐 - longlybits - 博客园
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 结构体字节对齐
&&&&& 在用sizeof运算符求算某结构体所占空间时，并不是简单地将结构体中所有元素各自占的空间相加，这里涉及到内存字节对齐的问题。从理论上讲，对于任何 变量的访问都可以从任何地址开始访问，但是事实上不是如此，实际上访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列， 而不是简单地顺序排列，这就是内存对齐。
&&&&& 内存对齐的原因：
&&&&& 1)某些平台只能在特定的地址处访问特定类型的数据；
&&&&& 2)提高存取数据的速度。比如有的平台每次都是从偶地址处读取数据，对于一个int型的变量，若从偶地址单元处存放，则只需一个读取周期即可读取该变量；但是若从奇地址单元处存放，则需要2个读取周期读取该变量。
&&&&&& win32平台下的微软C编译器对齐策略：
&&&&& 1)结构体变量的首地址能够被其最宽数据类型成员的大小整除。编译器在为结构体变量开辟空间时，首先找到结构体中最宽的数据类型，然后寻找内存地址能被该数据类型大小整除的位置，这个位置作为结构体变量的首地址。而将最宽数据类型的大小作为对齐标准。
&&&&& 2)结构体每个成员相对结构体首地址的偏移量(offset)都是每个成员本身大小的整数倍，如有需要会在成员之间填充字节。编译器在为结构体成员开辟空 间时，首先检查预开辟空间的地址相对于结构体首地址的偏移量是否为该成员大小的整数倍，若是，则存放该成员；若不是，则填充若干字节，以达到整数倍的要 求。
&&&&& 3)结构体变量所占空间的大小必定是最宽数据类型大小的整数倍。如有需要会在最后一个成员末尾填充若干字节使得所占空间大小是最宽数据类型大小的整数倍。
下面看一下sizeof在计算结构体大小的时候具体是怎样计算的
1.test1&& 空结构体
typedef struct node
则sizeof(S)=1;或sizeof(S)=0;
在C++中占1字节，而在C中占0字节。
typedef struct node1
&&&&int a;
&&&&char b;
&&&&short c;
则sizeof(S1)=8。这是因为结构体node1中最长的数据类型是int，占4个字节，因此以4字节对齐，则该结构体在内存中存放方式为
|--------int--------|&& 4字节
|char|----|--short-|&& 4字节
总共占8字节
typedef struct node2
&&&&char a;
&&&&int b;
&&&&short c;
&则siezof(S3)=12.最长数据类型为int，占4个字节。因此以4字节对齐，其在内存空间存放方式如下:
|char|----|----|----|& 4字节
|--------int--------|& 4字节
|--short--|----|----|& 4字节
总共占12个字节
4.test4& 含有静态数据成员&
typedef struct node3
&&&&int a;
&&&&short b;
&&&&static int c;
则sizeof(S3)=8.这里结构体中包含静态数据成员，而静态数据成员的存放位置与结构体实例的存储地址无关(注意只有在C++中结构体中才能含有静态数据成员，而C中结构体中是不允许含有静态数据成员的)。其在内存中存储方式如下：
|--------int--------|&& 4字节
|--short-|----|----|&&& 4字节
而变量c是单独存放在静态数据区的，因此用siezof计算其大小时没有将c所占的空间计算进来。
5.test5& 结构体中含有结构体
typedef struct node4
&&&&bool a;
&&&&S1 s1;
&&&&short b;
则sizeof(S4)=16。是因为s1占8字节，而s1中最长数据类型为int，占4个字节，bool类型1个字节，short占2字节，因此以4字节对齐，则存储方式为
|-------bool--------|& 4字节
|-------s1----------|& 8字节
|-------short-------|& 4字节
typedef struct node5
&&&&bool a;
&&&&S1 s1;
&&&&double b;
&&&&int c;
则sizeof(S5)=32。是因为s1占8字节，而s1中最长数据类型为int，占4字节，而double占8字节，因此以8字节对齐，则存放方式为：
|--------bool--------|&&& 8字节
|---------s1---------|&&& 8字节
|--------double------|&&& 8字节
|----int----|---------|&&&& 8字节&
若在程序中使用了#pragma pack(n)命令强制以n字节对齐时，默认情况下n为8.
则比较n和结构体中最长数据类型所占的字节大小，取两者中小的一个作为对齐标准。
若需取消强制对齐方式，则可用命令#pragma pack()
如果在程序开头使用命令#pragma pack(4)，对于下面的结构体
typedef struct node5
&&&&bool a;
&&&&S1 s1;
&&&&double b;
&&&&int c;
则sizeof(S5)=24.因为强制以4字节对齐，而S5中最长数据类型为double，占8字节，因此以4字节对齐。在内存中存放方式为：
& |-----------a--------|&& 4字节
& |--------s1----------|&& 4字节
& |--------s1----------|&& 4字节
& |--------b-----------|&& 4字节
& |--------b-----------|&& 4字节
&&|---------c----------|&&& 4字节
总结一下，在计算sizeof时主要注意一下几点：
1)若为空结构体，则只占1个字节的单元
2)若结构体中所有数据类型都相同，则其所占空间为 成员数据类型长度&成员个数
若结构体中数据类型不同，则取最长数据类型成员所占的空间为对齐标准，数据成员包含另一个结构体变量t的话，则取t中最 长数据类型与其他数据成员比较，取最长的作为对齐标准，但是t存放时看做一个单位存放，只需看其他成员即可。
3)若使用了#pragma pack(n)命令强制对齐标准，则取n和结构体中最长数据类型占的字节数两者之中的小者作为对齐标准。
另外除了结构体中存在对齐之外，普通的变量存储也存在字节对齐的情况，即自身对齐。编译器规定：普通变量的存储首地址必须能被该变量的数据类型宽度整除。
测试程序：
#include &iostream&
using namespace
typedef struct node
typedef struct node1
&&&&int a;
&&&&char b;
&&&&short c;
typedef struct node2
&&&&char a;
&&&&int b;
&&&&short c;
typedef struct node3
&&&&int a;
&&&&short b;
&&&&static int c;
typedef struct node4
&&&&bool a;
&&&&S1 s1;
&&&&short b;
typedef struct node5
&&&&bool a;
&&&&S1 s1;
&&&&double b;
&&&&int c;
int main(int argc, char *argv[])
&&&&cout&&sizeof(char)&&" "&&sizeof(short)&&" "&&sizeof(int)&&" "&&sizeof(float)&&" "&&sizeof(double)&&
&&&&S1 s1;
&&&&S2 s2;
&&&&S3 s3;
&&&&S4 s4;
&&&&S5 s5;
&&&&cout&&sizeof(S3)&&
&&&&cout&&sizeof(s)&&" "&&sizeof(s1)&&" "&&sizeof(s2)&&" "&&sizeof(s3)&&" "&&sizeof(s4)&&" "&&sizeof(s5)&&
&&&&return 0;85585人阅读
C基础（85）
&文章最后本人做了一幅图，一看就明白了，这个问题网上讲的不少，但是都没有把问题说透。　　一、概念 　　 　　 对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍，他就被称做自然对齐。比如在32位cpu下，假设一个整型变量的地址为0x，那它就是自然对齐的。　　 　　二、为什么要字节对齐　　 　　 需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐，比如为0x，则CPU如果取它的值的话需要访问两次内存，第一次取从0xx的一个short，第二次取从0xx的一个short然后组合得到所要的数据，如果变量在0x地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，然后组合得到整型数据。而如果变量在自然对齐位置上，则只要一次就可以取出数据。一些系统对对齐要求非常严格，比如sparc系统，如果取未对齐的数据会发生错误，举个例：　　 　　char ch[8];　　char *p = &ch[1];　　int i = *(int *)p;　　 　　　　运行时会报segment error，而在x86上就不会出现错误，只是效率下降。　　　　三、正确处理字节对齐　　　　 对于标准数据类型，它的地址只要是它的长度的整数倍就行了，而非标准数据类型按下面的原则对齐：　　　　数组 ：按照基本数据类型对齐，第一个对齐了后面的自然也就对齐了。 　　联合 ：按其包含的长度最大的数据类型对齐。 　　结构体： 结构体中每个数据类型都要对齐。　　比如有如下一个结构体：　　　　struct stu{　　　　　　 char name[10];　　};　　struct stu my_　　 　　　　由于在x86下，GCC默认按4字节对齐，它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。于是我们sizeof(my_stu)会得到长度为20，而不是15.　　　　四、__attribute__选项　　　　我们可以按照自己设定的对齐大小来编译程序，GNU使用__attribute__选项来设置，比如我们想让刚才的结构按一字节对齐，我们可以这样定义结构体　　　　struct stu{　　　　　　 char name[10];　　}__attribute__ ((aligned (1))); 　　　　struct stu my_　　 　　　　则sizeof(my_stu)可以得到大小为15。　　　　上面的定义等同于　　　　struct stu{　　　　　　 char name[10];　　}__attribute__ ((packed)); 　　struct stu my_　　 　　　　__attribute__((packed))得变量或者结构体成员使用最小的对齐方式，即对变量是一字节对齐，对域（field）是位对齐.　　　　五、什么时候需要设置对齐　　　　 在设计不同CPU下的通信协议时，或者编写硬件驱动程序时寄存器的结构这两个地方都需要按一字节对齐。即使看起来本来就自然对齐的也要使其对齐，以免不同的编译器生成的代码不一样.&一、快速理解1. 什么是字节对齐？在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每个成员按其自然边界（alignment）分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。为了使CPU能够对变量进行快速的访问,变量的起始地址应该具有某些特性,即所谓的”对齐”. 比如4字节的int型,其起始地址应该位于4字节的边界上,即起始地址能够被4整除.2. 字节对齐有什么作用？字节对齐的作用不仅是便于cpu快速访问，同时合理的利用字节对齐可以有效地节省存储空间。对于32位机来说，4字节对齐能够使cpu访问速度提高，比如说一个long类型的变量，如果跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。但是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度降低。所以这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 也是默认4字节对齐。3. 更改C编译器的缺省字节对齐方式在缺省情况下，C编译器为每一个变量或是数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变缺省的对界条件：· 使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。· 使用伪指令#pragma pack ()，取消自定义字节对齐方式。另外，还有如下的一种方式：· __attribute((aligned (n)))，让所作用的结构成员对齐在n字节自然边界上。如果结构中有成员的长度大于n，则按照最大成员的长度来对齐。· __attribute__ ((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。4. 举例说明例1struct test{char x1;short x2;float x3;char x4;};由于编译器默认情况下会对这个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字节对齐这时候sizeof(struct test)的值为8。例3#define GNUC_PACKED __attribute__((packed))struct PACKED test{char x1;short x2;float x3;char x4;}GNUC_PACKED;这时候sizeof(struct test)的值仍为8。二、深入理解什么是字节对齐,为什么要对齐?TragicJun 发表于
9:41:00 现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。&&&&& 对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。显然在读取效率上下降很多。二.字节对齐对程序的影响:&&&&&&& 先让我们看几个例子吧(32bit,x86环境,gcc编译器):设结构体如下定义：struct A{&&&&&&&&&&&&&&&&&&&&&};struct B{&&&&&&&&&&&&&&&&&&&&&};现在已知32位机器上各种数据类型的长度如下:char:1(有符号无符号同)&&&short:2(有符号无符号同)&&&int:4(有符号无符号同)&&&long:4(有符号无符号同)&&&float:4&&&&&&& double:8那么上面两个结构大小如何呢?结果是:sizeof(strcut A)值为8sizeof(struct B)的值却是12结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也一样;按理说A,B大小应该都是7字节。之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么我们是不是可以改变编译器的这种默认对齐设置呢,当然可以.例如:#pragma pack (2) /*指定按2字节对齐*/struct C{&&&&&&&&&&&&&&&&&&&&&};#pragma pack () /*取消指定对齐，恢复缺省对齐*/sizeof(struct C)值是8。修改对齐值为1：#pragma pack (1) /*指定按1字节对齐*/struct D{&&&&&&&&&&&&&&&&&&&&&};#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{&&&&&&&&&&&&&&&&&&&&&};假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，所以其有效对齐值为1，所以其存放地址0x0000符合0x.第二个成员变量a，其自身对齐值为4，所以有效对齐值也为4，所以只能存放在起始地址为0x7这四个连续的字节空间中，复核0x,且紧靠第一个变量。第三个变量c,自身对齐值为2，所以有效对齐值也是2，可以存放在0x9这两个字节空间中，符合0x。所以从0x9存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）所以就是4，所以结构体的有效对齐值也是4。根据结构体圆整的要求，0x0=10字节，（10＋2）％4＝0。所以0x0000A到0x000B也为结构体B所占用。故B从0xB共有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{&&&&&&&&&&&&&&&&&&&&&};#pragma pack () /*取消指定对齐，恢复缺省对齐*/第一个变量b的自身对齐值为1，指定对齐值为2，所以，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x;第二个变量，自身对齐值为4，指定对齐值为2，所以有效对齐值为2，所以顺序存放在0x3、0x5四个连续字节中，符合0x。第三个变量c的自身对齐值为2，所以有效对齐值为2，顺序存放在0x7中，符合0x。所以从0x07共八字节存放的是C的变量。又C的自身对齐值为4，所以C的有效对齐值为2。又8%2=0,C只占用0x7的八个字节。所以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 reserved[3];//使用空间换时间&&&&&&&&&&&&&&}reserved成员对我们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,当然即使不加这个成员通常编译器也会给我们自动填补对齐,我们自己加上它只是起到显式的提醒作用.六.字节对齐可能带来的隐患:&&&&&&& 代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。例如：unsigned int i = 0x;unsigned char *p=NULL;unsigned short *p1=NULL;p=&i;*p=0x00;p1=(unsigned short *)(p+1);*p1=0x0000;最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。在x86上，类似的操作只会影响效率，但是在MIPS或者sparc上，可能就是一个error,因为它们要求必须字节对齐.七.如何查找与字节对齐方面的问题:如果出现对齐或者赋值问题首先查看1. 编译器的big little端设置2. 看这种体系本身是否支持非对齐访问3. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作举例：#include &stdio.h&
struct A {
struct B {
#pragma pack (2) /*指定按2字节对齐*/
struct C {
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
#pragma pack (1) /*指定按1字节对齐*/
struct D {
#pragma pack ()/*取消指定对齐，恢复缺省对齐*/
int s1=sizeof(struct A);
int s2=sizeof(struct B);
int s3=sizeof(struct C);
int s4=sizeof(struct D);
printf(&%d\n&,s1);
printf(&%d\n&,s2);
printf(&%d\n&,s3);
printf(&%d\n&,s4);
}输出：<span style="color:#009900;BACKGROUND-COLOR: #<span style="color:#009900;BACKGROUND-COLOR: #<span style="color:#009900;BACKGROUND-COLOR: #<span style="color:#009900;BACKGROUND-COLOR: #&修改代码：struct A {&&&//&&&&&&};struct B {&&&&&&//&&&};输出：<span style="color:#009900;BACKGROUND-COLOR: #<span style="color:#009900;BACKGROUND-COLOR: #输出都是4，说明之前的int影响对齐！看图就明白了
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：9035960次
积分：91902
积分：91902
排名：第8名
原创：1532篇
转载：141篇
评论：3920条
(2)(1)(2)(1)(2)(2)(3)(10)(7)(4)(3)(1)(8)(2)(2)(1)(3)(3)(1)(2)(2)(2)(2)(1)(4)(20)(13)(2)(12)(11)(14)(22)(55)(16)(9)(20)(66)(27)(36)(67)(124)(44)(1)(8)(21)(2)(2)(1)(1)(5)(5)(1)(4)(16)(1)(3)(8)(1)(1)(4)(4)(10)(505)(18)(1)(19)(50)(67)(298)2011年2月 C/C++大版内专家分月排行榜第二2010年2月 C/C++大版内专家分月排行榜第二2009年12月 C/C++大版内专家分月排行榜第二2009年11月 C/C++大版内专家分月排行榜第二
2009年10月 C/C++大版内专家分月排行榜第三
2011年2月 C/C++大版内专家分月排行榜第二2010年2月 C/C++大版内专家分月排行榜第二2009年12月 C/C++大版内专家分月排行榜第二2009年11月 C/C++大版内专家分月排行榜第二
2009年10月 C/C++大版内专家分月排行榜第三
2011年9月 C/C++大版内专家分月排行榜第二2011年4月 C/C++大版内专家分月排行榜第二2010年11月 C/C++大版内专家分月排行榜第二
2011年6月 C/C++大版内专家分月排行榜第三
2011年2月 C/C++大版内专家分月排行榜第二2010年2月 C/C++大版内专家分月排行榜第二2009年12月 C/C++大版内专家分月排行榜第二2009年11月 C/C++大版内专家分月排行榜第二
2009年10月 C/C++大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。