结构体的存储--在内存中的对齐问题
c++内存中字节对齐问题详解
默认情况下GCC编译环境中是4字节对齐，VC里面默认8字节对齐。
一、什么是字节对齐,为什么要对齐?
现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特
定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的CPU在访问
一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对
数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那
么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数
据。显然在读取效率上下降很多。
二、请看下面的结构：
struct MyStruct&
double dda1;&
对结构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位系统)。&
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）&
偏移量必须为sizeof(char)即1的倍数&
偏移量必须为sizeof(int)即4的倍数&
偏移量必须为sizeof(float)即4的倍数&
偏移量必须为sizeof(double)即8的倍数&
偏移量必须为sizeof(short)即2的倍数&
各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。&
下面用前面的例子来说明VC到底怎么样来存放结构的。&
struct MyStruct&
double dda1;&
为上面的结构分配空间的时候，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&
这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明）&
struct MyStruct&
//偏移量为0，满足对齐方式，dda占用1个字节；&
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&
double m4;&
#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{
struct S2 {
#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个字节.
S1的内存布局：11**,1111,
c S1.a S1.b d
S2的内存布局：1***,11**,1111,****
这里有三点很重要:
1.每个成员分别按自己的方式对齐,并能最小化长度。
2.复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度。
3.对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。1.c++性能大概比c慢30%，但是开发效率要比c快很多。2.匿名结构体 : 锁定变量的个数#include &stdio.h&#include &stdlib.h&&& &struct //匿名结构体{&& &&& &}*p, x[10],
3.一个结构体或联合至少要存在一个成员。
4.数组名与指针的区别是一个是变量一个是常量。5.任何指针在win32情况下都只占4个字节。6.通过地址访问元素(&csdndata[i])-&email不加括号会 有优先级的问题。 和 csdndata[i].email 是一样的。7.alloca分配的内存在栈上，malloc在堆上。struct csdn *p1 = alloc(sizeof(struct csdn)*num);memset(void *s, char ch, size_t n)将s所指向的某一块内存中的每一个字节的内容全部设置成ch指定的ASCII值，块的大小是该指针指向的地址后面的n个字节。注意0代表的就是NULL。存储在堆上是需要free去释放内存的，而存储在栈上是不需要去free的。8.结构体大小内存对齐:
结构体中成员按照定义时的顺序依次存储在连续的内存空间。但并不是像数组那样的连续。内存对齐计算内存地址比较方便，内存地址会非常有规律，减小了内存寻址时间。若不对齐，内存地址的变化非常没有规律，内存地址往往是在寄存器里计算出来的基本类型指的是像char、int、float、double这样的内置数据类型
结构体总大小大于等于所有成员的大小之和。
结构体的总大小必须可以整除最宽基本成员。
结构体成员的地址-结构体的首地址 = 偏移量，必须是当前成员整数倍
结构体尾部不足的部分，就会被填充。 整数包括正整数、0、负整数， 吧
当只用一个成员时不存在对齐。
两者取最短原则。(详情请看下面的补充)
char num2;
//偏移量是4，可以整除1，
double num3;
// 偏移量是13，要想整除8，需要在char后边填充三个字节
char num4;
//加上这个就是17个字节了，要想让它能够整除最宽的基本成员，需要在char后边填充7个字节
};总字节是24字节。
我是这么理解的，就是偏移量不知道理解的对不对补充：数组和字符串都不属于最宽基本成员。要不然你弄个数组里边包含几十个元素，那么拿他对齐那得有多大的内存呀。
struct Mystruct
char str[13];
　　//该结构体占用24个字节毋庸置疑
struct Mystructx
char　　//结构体嵌套的情况下，最宽基本成员不局限于当前的结构体，会把被嵌套的结构体成员也算上。。
};　　//这个结构体占用32个字节
关于两者取最短：(这个主要说的是你编译器的设置)
struct Mystruct
　　char str[23];　　　　//若是你用编译器设置的结构体对齐宽度是4字节，在结构体中如果没有比4短的就取4，如果有short就取2为最短，两者之间取最短的为最宽基本成员。}
阅读(...) 评论()温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
输出：81287&修改代码：struct A {&&&//&&&&&&};struct B {&&&&&&//&&&};输出：44输出都是4，说明之前的int影响对齐！
阅读(2778)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
在LOFTER的更多文章
loftPermalink:'',
id:'fks_',
blogTitle:'内存字节对齐---对结构体非常重要。不能用memcpy简单的移动指针进行赋值',
blogAbstract:'　　一、概念&　　&　　 对齐跟数据在内存中的位置有关。如果一个变量的内存地址正好位于它长度的整数倍，他就被称做自然对齐。比如在32位cpu下，假设一个整型变量的地址为0x，那它就是自然对齐的。　　&　　二、为什么要字节对齐　　&　　 需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐，比如为0x，则CPU如果取它的值的话需要访问两次内存，第一次取从0xx的一个short，第二次取从0xx的一个short然后组合得到',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:0,
publishTime:9,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:1,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'1',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}下次自动登录
现在的位置:
& 综合 & 正文
一个微软面试题–关于位结构体 及 位操作总结
C语言位运算符及常见用法
备案待查，指不定啥时候就用上了。
写出下列在X86上的运行结果。
struct mybitfields
unsigned short a : 4;
unsigned short b : 5;
unsigned short c : 7;
void main(void)
i=*((short *)&test);
printf("%d ",i);
这个题的为难之处呢，就在于前面定义结构体里面用到的冒号，如果你能理解这个符号的含义，那么问题就很好解决了。这里的冒号相当于分配几位空间，也即在定义结构体的时候，分配的成员a4位的空间， b 5位，c7位，一共是16位，正好两个字节。下面画一个简单的示意：
11 10 9 |8 7 6 5 4 |3 2 1 0
|00 0 1 1 |
在执行i=*((short *)&test);时，取从地址&test开始两个字节（short占两个字节）的内容转化为short型数据，即为0x0032，再转为int型为0x，即50。输出的结果就是50。当然，这里还涉及到字节及位的存储顺序问题，后面再说。
前面定义的结构体被称为位结构体。所谓位结构体，是一种特殊的结构体，在需要按位访问字节或字的一个或多个位时，位结构体比按位操作要更方便一些。
位结构体的定义方式如下：
struct [位结构体名]{
数据类型 变量名:整数常数;
}位结构变量;
1）这里的数据类型只能为int型（包括signed和unsigned）；
2）整数常数必须为0~15之间的整数，当该常数为1时，数据类型为unsigned（显然嘛，只有一位，咋表示signed？光一符号？没意义呀）；
3）按数据类型变量名:整数常数;方式定义的结构成员称为位结构成员，好像也叫位域，在一个位结构体中，可以同时包含位结构成员及普通的结构成员；
4）位结构成员不能是指针或数据，但结构变量可以是指针或数据；
5）位结构体所占用的位数由各个位结构成员的位数总各决定。如在前面定义的结构体中，一共占用4+5+7＝16位，两个字节。另外我们看到，在定义位结构成员时，必须指定数据类型，这个数据类型在位结构体占用多少内存时也起到不少的作用。举个例子：
struct mybitfieldA{
struct mybitfieldB{
short a:4;
short b:3;
这里，testA占用一个字节，而testB占用两个字节。知道原因了吧。在testA中，是以char来定义位域的，char是一个字节的，因此，位域占用的单位也按字节做单位，也即，如果不满一个字节的话按一个字节算（未定义的位按零处理）。而在testB中，short为两个字节，所以了，不满两个字节的都按两个字节算（未定义位按零处理）
关于位结构体在内存中的存储问题
Kevin's Theory #2: In a C structure that contains bit fields,if field A is defined in front of field B, then field A alwaysoccupies a lower bit address than field B. （来自）
说的是，在C结构体中，如果一个位域A在另一个位域B之前定义，那么位域A将存储在比B小的位地址中。
如果一个位域有多个位时，各个位的排列顺序通常是按CPU的端模式(Endianess）来进行的，即在大端模式(bigendian）下，高有效位在低位地址，小端模式则相反。
补充说明一个关于位域与普通结构成员一起使用的问题
先看一个例子
struct mybitfield{
char c:1;}
这种情况下，test应该占几个字节呢？2个（4+3+1＝8占一个字节，aa占一个）还是3个（4+3不足补一位，占一个字节，aa占一个字节，c占一个字节）？
写个小程序验证一下：
int main(int argc, char* argv[])
test.a = 1;
test.b = 1;
test.aa = 1;
test.c = 1;
i=*((short*)&test);
printf("%d \n",i);
输出结果是273，化为十六进制数0x111，可见是按三个字节来处理了（如果按两个字节处理的话，cba组成一个字节，是（十六进制0x91）再加上aa，那就应该是0x191了）
举这个例子是为了说明一下，定义位域的话，最好是把所有位域放在一起，这样可以节省空间（如果把c和aa换一下位置，那test就只占两个字节了）。另外也是为了强调一下位结构体的内存分配方式，按定义的先后顺序来分配，而位域（或成员）内的字节顺序则按照CPU的位顺序来进行（一般与CPU的端模式对应）。
总结如下：
一。内存对齐
许多计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数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的整数倍来进行判断是否添加填充。
看如下例子：
structT{char ch;double d ;};
那么在GCC下，sizeof(T)应该等于12个字节。
如果结构体中含有位域(bit-field)，那么VC中准则又要有所更改：1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式（不同位域字段存放在不同的位域类型字节中），Dev-C++和GCC都采取压缩方式；备注：当两字段类型不一样的时候，对于不压缩方式，例如：
structN{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) 如果位域字段之间穿插着非位域字段，则不进行压缩；备注：
结构体5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
typedefstruct{
int c2:4;}N3;
在GCC下占据的空间为16字节，在VC下占据的空间应该是24个字节。
对齐模数的选择只能是根据基本数据类型，所以对于结构体中嵌套结构体，只能考虑其拆分的基本数据类型。而对于对齐准则中的第2条，确是要将整个结构体看成是一个成员，成员大小按照该结构体根据对齐准则判断所得的大小。
类对象在内存中存放的方式和结构体类似，这里就不再说明。需要指出的是，类对象的大小只是包括类中非静态成员变量所占的空间，如果有虚函数，那么再另外增加一个指针所占的空间即可。
内存对齐与编译器设置有关，首先要搞清编译器这个默认值是多少
如果不想编译器默认的话，可以通过#pragma pack(n)来指定按照n对齐
每个结构体变量对齐，如果对齐参数n(编译器默认或者通过pragma指定)大于该变量所占字节数(m)，那么就按照m对齐，内存偏移后的地址是m的倍数，否则是按照n对齐，内存偏移后的地址是n的倍数。也就是最小化长度规则
结构体总大小:对齐后的长度必须是成员中最大的对齐参数的整数倍。最大对齐参数是从第三步得到的。
补充：如果结构体A中还要结构体B，那么B的对齐方式是选它里面最长的成员的对齐方式
有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域， 并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：
struct 位域结构名
{ 位域列表 };
其中位域列表的形式为： 类型说明符 位域名：位域长度
位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：
说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：
1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：
unsigned a:4
unsigned :0 /*空域*/
unsigned b:4 /*从下一单元开始存放*/
unsigned c:4
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。
2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。
3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：
int :2 /*该2位不能使用*/
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。
三。位域的使用
位域的使用和结构成员的使用相同，其一般形式为： 位域变量名·位域名 位域允许用各种格式输出。
unsigned a:1;
unsigned b:3;
unsigned c:4;
printf("%d,%d,%d/n",bit.a,bit.b,bit.c);
pbit-&a=0;
pbit-&b&=3;
pbit-&c|=1;
printf("%d,%d,%d/n",pbit-&a,pbit-&b,pbit-&c);
上例程序中定义了位域结构bs，三个位域为a,b,c。说明了bs类型的变量bit和指向bs类型的指针变量pbit。这表示位域也是可以使用指针的。
程序的9、10、11三行分别给三个位域赋值。( 应注意赋值不能超过该位域的允许范围)程序第12行以整型量格式输出三个域的内容。第13行把位域变量bit的地址送给指针变量pbit。第14行用指针方式给位域a重新赋值，赋为0。第15行使用了复合的位运算符"&="， 该行相当于： pbit-&b=pbit-&b&3位域b中原有值为7，与3作按位与运算的结果为3(111&011=011,十进制值为3)。同样，程序第16行中使用了复合位运算"|="， 相当于： pbit-&c=pbit-&c|1其结果为15。程序第17行用指针方式输出了这三个域的值。
一、位运算符Ｃ语言提供了六种位运算符：
^ 按位异或
1. 按位与运算
按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。
例如：9&5可写算式如下： 的二进制补码)&的二进制补码)　的二进制补码)可见9&5=1。
　　按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为1111)。
int a=9,b=5,c;
printf("a=%d/nb=%d/nc=%d/n",a,b,c);
2. 按位或运算
按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。
例如：9|5可写算式如下： 00101
(十进制为13)可见9|5=13
int a=9,b=5,c;
printf("a=%d/nb=%d/nc=%d/n",a,b,c);
3. 按位异或运算
按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00 (十进制为12)
printf("a=%d/n",a);
4. 求反运算
求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(1001)结果为：0110
5. 左移运算
左移运算符“&&”是双目运算符。其功能把“&& ”左边的运算数的各二进位全部左移若干位，由“&&”右边的数指定移动的位数，
高位丢弃，低位补0。例如： a&&4 指把a的各二进位向左移动4位。如a=(十进制3)，左移4位后为(十进制48)。
6. 右移运算
右移运算符“&&”是双目运算符。其功能是把“&& ”左边的运算数的各二进位全部右移若干位，“&&”右边的数指定移动的位数。
例如：设 a=15，a&&2　表示把右移为(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。
unsigned a,b;
printf("input a number: ");
scanf("%d",&a);
printf("a=%d/tb=%d/n",a,b);
请再看一例!
char a='a',b='b';
int p,c,d;
p=(p&&8)|b;
c=(p&0xff00)&&8;
printf("a=%d/nb=%d/nc=%d/nd=%d/n",a,b,c,d);
二进制 补码 的简便求法:
正的二进制数的补码就是原码。
负的二进制数的补码，符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。
1)、在计算机系统中，数值一律用补码来表示（存储）。 主要原因：使用补码，可以将符号位和其它位统一处理；同时，减法也可按加法来处理。另外，两个用补 码表示的数相加时，如果最高位（符号位）有进位，则进位被舍弃。
(2)、补码与原码的转换过程几乎是相同的
&&&&推荐文章:
【上篇】【下篇】}