结构体内存分配及sizeof用法.docx
《结构体内存分配及sizeof用法.docx》由会员分享，可在线阅读，更多相关《结构体内存分配及sizeof用法.docx（22页珍藏版）》请在冰豆网上搜索。
结构体内存分配及sizeof用法
结构体成员的内存分布与对齐
马国峻
maguojun2005@
我们先看一道IBM和微软的笔试题：
IBM笔试题：
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
微软笔试题：
structexample1
{
shorta;
longb;
};
structexample2
{
charc;
example1struct1;
shorte;
};
intmain（intargc,char*argv[]）
{
example2e2;
intd=（unsignedint）&e2.struct1-（unsignedint）&e2.c;
printf（"%d,%d,%d\n",sizeof（example1）,sizeof（example2）,d）;
return0;
}
输出结果？
要能清除的分析上面的问题就要搞清楚结构体变量的成员在内存里是如何分布的、成员先后顺序是怎样的、成员之间是连续的还是分散的、还是其他的什么形式？
其实这些问题既和软件相关又和硬件相关。
所谓软件相关主要是指和具体的编程语言的编译器的特性相关，编译器为了优化CPU访问内存的效率，在生成结构体成员的起始地址时遵循着某种特定的规则，这就是所谓的结构体成员“对齐”；所谓硬件相关主要是指CPU的“字节序”问题，也就是大于一个字节类型的数据如int类型、short类型等，在内存中的存放顺序，即单个字节与高低地址的对应关系。
字节序分为两类：
Big-Endian和Little-Endian，有的文章上称之为“大端”和“小端”，他们是这样定义的：
Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端；Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
Intel、VAX和Unisys处理器的计算机中的数据的字节顺序是Little-Endian，IBM大型机和大多数Unix平台的计算机中字节顺序是Big–Endian。
关与Big-Endian和Little-Endian问题本文暂不做详细讨论，本文将以小端机（此处为intelx86架构的计算机）、OS：
WindowsXp和VC++6.0编译器来详细讨论结构体成员的“对齐”问题。
前面说了,为了优化CPU访问内存的效率，程序语言的编译器在做变量的存储分配时就进行了分配优化处理，优化规则大致原则是这样:
对于n字节的元素（n=2,4,8,...），它的首地址能被n整除，这种原则称为“对齐”，如WORD（2字节）的值应该能被2整除的位置，DWORD（4字节）应该在能被4整除的位置。
对于结构体来说，结构体的成员在内存中顺序存放，所占内存地址依次增高，第一个成员处于低地址处，最后一个成员处于最高地址处，但结构体成员的内存分配不一定是连续的，编译器会对其成员变量依据前面介绍的“对齐”原则进行处理。
对待每个成员类似于对待单个n字节的元素一样，依次为每个元素找一个适合的首地址，使得其符合上述的“对齐”原则。
通常编译器中可以设置一个对齐参数n，但这个n并不是结构体成员实际的对齐参数，VC++6.0中结构体的每个成员实际对齐参数N通常是这样计算得到的N=min（sizeof（该成员类型），n）（n为VC++6.0中可设置的值）。
成员的内存分配规律是这样的：
从结构体的首地址开始向后依次为每个成员寻找第一个满足条件的首地址x，该条件是x%N=0，并且整个结构的长度必须为各个成员所使用的对齐参数中最大的那个值的最小整数倍,不够就补空字节。
结构体中所有成员的对齐参数N的最大值称为结构体的对齐参数。
VC++6.0中n默认是8个字节，可以修改这个设定的对齐参数，方法为在菜单“工程”的“设置”中的“C/C++”选项卡的“分类”中“CodeGeneration”的“Structmemberalignment”中设置，1byte、2byte、4byte、8byte、16byte等几种，默认为8byte
也可以程序控制，采用指令：
#pragma pack（xx）控制
如#pragma pack
（1）,1字节对齐，#pragma pack（4），4字节对齐
#pragma pack（16），16字节对齐
接下来我们将分不同的情况来详细讨论结构体成员的分布情况，顺便提醒一下，常见类型的长度：
Int4byte,Short2byte,Char1byte,Double8byte,Long4byte
让我们先看下例：
structA
{
charc;//1byte
doubled;//8byte
shorts;//2byte
inti;//4byte
};
intmain（intargc,char*argv[]）
{
Astrua;
printf（"%len:
d\n",sizeof（A））;
printf（"%d,%d,%d,%d",&strua.c,&strua.d,&strua.s,&strua.i）;
return0;
}
1）n设置为8byte时
结果：
len:
24,
1245032,1245040,1245048,1245052
内存中成员分布如下：
strua.c分配在一个起始于8的整数倍的地址1245032（为什么是这样读者先自己思考，读完就会明白），接下来要在strua.c之后分配strua.d，由于double为8字节,取N=min（8,8），8字节来对齐，所以从strua.c向后找第一个能被8整除的地址，所以取1245032+8得1245040,strua.s为2byte小于参数n,所以N=min（2，8），即N=2，取2字节长度对齐，所以要从strua.d后面寻找第一个能被2整除的地址来存储strua.s，由于strua.d后面的地址为1245048可以被2整除，所以strua.s紧接着分配,现在来分配strua.i,int为4byte，小于指定对齐参数8byte，所以N=min（4，8）取N=4byte对齐，strua.s后面第一个能被4整除地址为1245048+4，所以在1245048+4的位置分配了strua.i，中间补空，同时由于所有成员的N值的最大值为8，所以整个结构长度为8byte的最小整数倍，即取24byte其余均补0.
于是该结构体的对齐参数就是8byte。
2）当对齐参数n设置为16byte时，结果同上，不再分析
3）当对齐参数设置为4byte时
上例结果为：
Len:
20
1245036,1245040,1245048,1245052
内存中成员分布如下：
Strua.c起始于一个4的整数倍的地址，接下来要在strua.c之后分配strua.d，由于strua.d长度为8byte，大于对齐参数4byte，所以N=min（8，4）取最小的4字节,所以向后找第一个能被4整除的地址来作为strua.d首地址，故取1245036+4，接着要在strua.d后分配strua.s，strua.s长度为2byte小于4byte，取N=min（2，4）2byte对齐，由于strua.d后的地址为1245048可以被2
整除，所以直接在strua.d后面分配，strua.i的长度为4byte，所以取N=min（4，4）4byte对齐，所以从strua.s向后找第一个能被4整除的位置即1245048+4来分配和strua.i，同时N的最大值为4byte，所以整个结构的长度为4byte的最小整数倍16byte
4）当对齐参数设置为2byte时
上例结果为：
Len:
16
1245040,1245042,1245050,1245052
Strua.c分配后，向后找一第一个能被2整除的位置来存放strua.d,依次类推
5）1byte对齐时：
上例结果为：
Len:
15
1245040,1245041,1245049,1245051
此时，N=min（sizeof（成员），1），取N=1，由于1可以整除任何整数，所以各个成员依次分配，没有间空，如下图所示：
6）当结构体成员为数组时，并不是将整个数组当成一个成员来对待，而是将数组的每个元素当一个成员来分配，其他分配规则不变，如将上例的结构体改为:
structA
{
charc;//1byte
doubled;//8byte
shorts;//2byte
charszBuf[5];
};
对齐参数设置为8byte，则，运行结果如下：
Len:
24
1245032,1245040,1245048,1245050
Strua的s分配后，接下来分配Strua的数组szBuf[5]，这里要单独分配它的每个元素，由于是char类型，所以N=min（1,8），取N=1，所以数组szBuf[5]的元素依次分配没有间隙。
7）当结构中有成员不是一个完整的类型单元，如int或short型，而是该类型的一段时，即位段时，如
structA
{
inta1:
5;
inta2:
9;
charc;
intb:
4;
shorts;
};
对于位段成员，存储是按其类型分配空间的，如int型就分配4个连续的存储单元，如果是相邻的同类型的段位成员就连续存放，共用存储单元，此处如a1,a2将公用一个4字节的存储单元，当该类型的长度不够用时，就另起一个该类型长度的存储空间。
有位段时的对齐规则是这样：
同类型的、相邻的可连续在一个类型的存储空间中存放的位段成员作为一个该类型的成员变量来对待，不是同类型的、相邻的位段成员，分别当作一个单独得该类型的成员来对待，分配一个完整的类型空间，其长度为该类型的长度，其他成员的分配规则不变，仍然按照前述的对齐规则进行。
对于structA,VC++6.0中n设置为8时，sizeof（A）=16,内存分布：
又如:
structB
{
inta:
5;
intb:
7;
intc:
6;
intd:
9;
chare:
2;
intx;
};
Vc++6.0的对齐参数设置为8、16、4字节对齐时，sizeof（A）=12内存分布为：
（灰色部分未使用）
当对齐参数设置为2字节时：
（灰色部分未使用）sizeof（A）=10
又如intel的笔试题：
#include “stdafx.h”
#include
struct bit
{
int a:
3;
int b:
2;
int c:
3;
};
int main（int argc, char* argv[]）
{
bit s;
char *c = （char*）&s;
*c = 0x99;
cout << s.a < return 0;
}
Output:
?
运行的结果是 1 -1 -4
结构bit的成员在内存中由低地址到高地址顺序存放，执行*c=0x99;后成员的内存分布情况为：
8）当结构体成员是结构体类型时，那么该过程是个递归过程，且把该成员作为一个整体来对待，如（微软笔试题）：
structexample1
{
shorta;
longb;
};
structexample2
{
charc;
example1struct1;
shorte;
};
intmain（intargc,char*argv[]）
{
example2e2;
intd=（unsignedint）&e2.struct1-（unsignedint）&e2.c;
printf（"%d,%d,%d\n",sizeof（example1）,sizeof（example2）,d）;
return0;
}
8byte对齐时，结果为：
8，16，4
内存分布为：
因为example1的对齐参数为4，分配完c后要接着分配struct1，这时的对齐参数为min（struct1的对齐参数，指定对齐参数），开始分配struct1，在struct1的成员分配过程中又是按照前述的规则来分配的。
关于结构体内存对齐
内存对齐”应该是编译器的“管辖范围”。
编译器为程序中的每个“数据单元”安排在适当的位置上。
但是C语言的一个特点就是太灵活，太强大，它允许你干预“内存对齐”。
如果你想了解更加底层的秘密，“内存对齐”对你就不应该再透明了。
一、内存对齐的原因
大部分的参考资料都是如是说的：
1、平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
二、对齐规则
每个特定平台上的编译器都有自己的默认“对齐系数”（也叫对齐模数）。
程序员可以通过预编译命令#pragmapack（n），n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。
对齐步骤：
1、数据成员对齐规则：
结构（struct）（或联合（union））的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragmapack指定的数值和这个数据成员自身长度中，比较小的那个进行。
2、结构（或联合）的整体对齐规则：
在数据成员完成各自对齐之后，结构（或联合）本身也要进行对齐，对齐将按照#pragmapack指定的数值和结构（或联合）最大数据成员长度中，比较小的那个进行。
3、结合1、2颗推断：
当#pragmapack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。
备注：
数组成员按长度按数组类型长度计算，如chart[9],在第1步中数据自身长度按1算，累加结构体时长度为9;第2步中，找最大数据长度时，如果结构体T有复杂类型成员A的，该A成员的长度为该复杂类型成员A的最大成员长度。
三、试验
我们通过一系列例子的详细说明来证明这个规则吧!
我试验用的编译器包括GCC3.4.2和VC6.0的C编译器，平台为WindowsXP+Sp2。
我们将用典型的struct对齐来说明。
首先我们定义一个struct：
#pragmapack（n）/*n=1,2,4,8,16*/
structtest_t{
inta;
charb;
shortc;
chard;
};
#pragmapack（n）
首先我们首先确认在试验平台上的各个类型的size，经验证两个编译器的输出均为：
sizeof（char）=1
sizeof（short）=2
sizeof（int）=4
我们的试验过程如下：
通过#pragmapack（n）改变“对齐系数”，然后察看sizeof（structtest_t）的值。
1、1字节对齐（#pragmapack
（1））
输出结果：
sizeof（structtest_t）=8[两个编译器输出一致]
分析过程：
1）成员数据对齐
#pragmapack
（1）
structtest_t{
inta; /*长度4<1按1对齐；起始offset=00%1=0；存放位置区间[0,3]*/
charb; /*长度1=1按1对齐；起始offset=44%1=0；存放位置区间[4]*/
shortc; /*长度2>1按1对齐；起始offset=55%1=0；存放位置区间[5,6]*/
chard; /*长度1=1按1对齐；起始offset=77%1=0；存放位置区间[7]*/
};
#pragmapack（）
成员总大小=8
2）整体对齐
整体对齐系数=min（（max（int,short,char）,1）=1
整体大小（size）=$（成员总大小）按$（整体对齐系数）圆整=8/*8%1=0*/[注1]
2、2字节对齐（#pragmapack
（2））
输出结果：
sizeof（structtest_t）=10[两个编译器输出一致]
分析过程：
1）成员数据对齐
#pragmapack
（2）
structtest_t{
inta; /*长度4>2按2对齐；起始offset=00%2=0；存放位置区间[0,3]*/
charb; /*长度1<2按1对齐；起始offset=44%1=0；存放位置区间[4]*/
shortc; /*长度2=2按2对齐；起始offset=66%2=0；存放位置区间[6,7]*/
chard; /*长度1<2按1对齐；起始offset=88%1=0；存放位置区间[8]*/
};
#pragmapack（）
成员总大小=9
2）整体对齐
整体对齐系数=min（（max（int,short,char）,2）=2
整体大小（size）=$（成员总大小）按$（整体对齐系数）圆整=10/*10%2=0*/
3、4字节对齐（#pragmapack（4））
输出结果：
sizeof（structtest_t）=12[两个编译器输出一致]
分析过程：
1）成员数据对齐
#pragmapack（4）
structtest_t{
inta; /*长度4=4按4对齐；起始offset=00%4=0；存放位置区间[0,3]*/
charb; /*长度1<4按1对齐；起始offset=44%1=0；存放位置区间[4]*/
shortc; /*长度2<4按2对齐；起始offset=66%2=0；存放位置区间[6,7]*/
chard; /*长度1<4按1对齐；起始offset=88%1=0；存放位置区间[8]*/
};
#pragmapack（）
成员总大小=9
2）整体对齐
整体对齐系数=min（（max（int,short,char）,4）=4
整体大小（size）=$（成员总大小）按$（整体对齐系数）圆整=12/*12%4=0*/
4、8字节对齐（#pragmapack（8））
输出结果：
sizeof（structtest_t）=12[两个编译器输出一致]
分析过程：
1）成员数据对齐
#pragmapack（8）
structtest_t{
inta; /*长度4<8按4对齐；起始offset=00%4=0；存放位置区间[0,3]*/
charb; /*长度1<8按1对齐；起始offset=44%1=0；存放位置区间[4]*/
shortc; /*长度2<8按2对齐；起始offset=66%2=0；存放位置区间[6,7]*/
chard; /*长度1<8按1对齐；起始offset=88%1=0；存放位置区间[8]*/
};
#pragmapack（）
成员总大小=9
2）整体对齐
整体对齐系数=min（（max（int,short,char）,8）=4
整体大小（size）=$（成员总大小）按$（整体对齐系数）圆整=12/*12%4=0*/
5、16字节对齐（#pragmapack（16））
输出结果：
sizeof（structtest_t）=12[两个编译器输出一致]
分析过程：
1）成员数据对齐
#pragmapack（16）
structtest_t{
inta; /*长度4<16按4对齐；起始offset=00%4=0；存放位置区间[0,3]*/
charb; /*长度1<16按1对齐；起始offset=44%1=0；存放位置区间[4]*/
shortc; /*长度2<16按2对齐；起始offset=66%2=0；存放位置区间[6,7]*/
chard; /*长度1<16按1对齐；起始offset=88%1=0；存放位置区间[8]*/
};
#pragmapack（）
成员总大小=9
2）整体对齐
整体对齐系数=min（（max（int,short,char）,16）=4
整体大小（size）=$（成员总大小）按$（整体对齐系数）圆整=12/*12%4=0*/
如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。
其实字节对齐的细节和具体编译器实现相关，但一般而言，满足三个准则：
1）结构体变量的首地址能够被其最宽基本类型成员的大小所整除； 2）结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节；例如上面第二个结构体变量的地址空间。
3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节。
sizeof用法总结
在VC中，sizeof有着许多的用法，而且很容易引起一些错误。
下面根据sizeof后面的参数对sizeof的用法做个总结。
A．参数为数据类型或者为一般变量。
例如sizeof（int）,sizeof（long）等等。
这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。
例如int类型在16位系统中占2个字节，在32位系统中占4个字节。
B．参数为数组或指针。
下面举例说明.
chara[50];//sizeof（a）=4*50=200;求数组所占的空间大小
charnew_int[50];
char*a=new_int[50];
//sizeof（a）=4;a为一个指针，sizeof（a）是求指针的大小,在32位系统中，当然是占4个字节。
//sizeof（*a）=1;这个表示求指针变量的数据类型所占空间大小
//sizeof（new_int）=50*1表示求取指针
升级会员 