结构体与位结构体

来源:互联网 发布:三菱系统手动编程实例 编辑:程序博客网 时间:2024/06/05 10:23

http://www.cnblogs.com/bigrabbit/archive/2012/09/20/2695543.html

C结构体之位域(位段)

有些信息在存储时,并不需要占用一个完整的字节, 而只需占几个或一个二进制位。例如在存放一个开关量时,只有0和1 两种状态, 用一位二进位即可。为了节省存储空间,并使处理简便,C语言又提供了一种数据结构,称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域, 并说明每个区域的位数。每个域有一个域名,允许在程序中按域名进行操作。 这样就可以把几个不同的对象用一个字节的二进制位域来表示。
一、位域的定义和位域变量的说明位域定义与结构定义相仿,其形式为: 

struct 位域结构名 { 位域列表};

其中位域列表的形式为:

类型说明符 位域名位域长度

位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明,同时定义说明或者直接说明这三种方式。例如:

struct bs{  int a:8;  int b:2;  int c:6;}data; 

说明data为bs变量,共占两个字节。其中位域a占8位,位域b占2位,位域c占6位。对于位域的定义尚有以下几点说明:


1. 一个位域必须存储在同一个字节中,不能跨两个字节。如一个字节所剩空间不够存放另一位域时,应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如:

struct bs{    unsigned a:4    unsigned b:5 /*从下一单元开始存放*/    unsigned c:4}

2. 由于位域不允许跨两个字节,因此位域的长度不能大于一个字节的长度

3. 位域可以无位域名,这时它只用来作填充或调整位置。无名的位域是不能使用的。例如:

复制代码
struct k{    int a:1    int :2 /*无位域名,该2位不能使用*/    int b:3    int c:2}; 
复制代码

二、位域的使用

下面例子是参加一个公司(白领科技-青岛)的笔试遇到的,当时做错了,为了怕忘了,赶紧写下来。

复制代码
 1 #include <iostream> 2 #include <memory.h> 3 using namespace std; 4 struct A 5 { 6     int a:5; 7     int b:3; 8 }; 9 int main(void)10 {11     char str[100] = "0134324324afsadfsdlfjlsdjfl";12         struct A d;13     memcpy(&d, str, sizeof(A));14     cout << d.a << endl;15     cout << d.b << endl;16     return 0;17 }
复制代码

在32位x86机器上输出:

?
$ ./langxun.exe
-16
1

解析:在默认情况下,为了方便对结构体内元素的访问和管理,当结构体内的元素长度都小于处理器的位数的时候,便以结构体里面最长的元素为对其单位,即结构体的长度一定是最长的数据元素的整数倍;如果有结构体内存长度大于处理器位数的元素,那么就以处理器的位数为对齐单元。由于是32位处理器,而且结构体中a和b元素类型均为int(也是4个字节),所以结构体的A占用内存为4个字节。

上例程序中定义了位域结构A,两个个位域为a(占用5位),b(占用3位),所以a和b总共占用了结构A一个字节(低位的一个字节)。

当程序运行到14行时,d内存分配情况:

 高位 00110100 00110011   00110001    00110000 低位
'4' '3' '1' '0'
其中d.a和d.b占用d低位一个字节(
00110000),d.a : 10000, d.b : 001

 d.a内存中二进制表示为10000,由于d.a为有符号的整型变量,输出时要对符号位进行扩展,所以结果为-16(二进制为11111111111111111111111111110000)

 d.b内存中二进制表示为001,由于d.b为有符号的整型变量,输出时要对符号位进行扩展,所以结果为1(二进制为00000000000000000000000000000001)

 三、位域的对齐

  如果结构体中含有位域(bit-field),那么VC中准则是:

  1) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字段将紧邻前一个字段存储,直到不能容纳为止;

  2) 如果相邻位域字段的类型相同,但其位宽之和大于类型的sizeof大小,则后面的字段将从新的存储单元开始,其偏移量为其类型大小的整数倍;

  3) 如果相邻的位域字段的类型不同,则各编译器的具体实现有差异,VC6采取不压缩方式(不同位域字段存放在不同的位域类型字节中),Dev-C++和GCC都采取压缩方式;

  系统会先为结构体成员按照对齐方式分配空间和填塞(padding),然后对变量进行位域操作。

二  二   二    二    二    二     二     二

C语言结构体对齐也是老生常谈的话题了。基本上是面试题的必考题。内容虽然很基础,但一不小心就会弄错。写出一个struct,然后sizeof,你会不会经常对结果感到奇怪?sizeof的结果往往都比你声明的变量总长度要大,这是怎么回事呢? 
开始学的时候,也被此类问题困扰很久。其实相关的文章很多,感觉说清楚的不多。结构体到底怎样对齐?
【结构体】
有人给对齐原则做过总结,具体在哪里看到现在已记不起来,这里引用一下前人的经验(在没有#pragma pack宏的情况下):
原则1、数据成员对齐规则:结构(struct或联合union)的数据成员,第一个数据成员放在offset为0的地方,以后每个数据成员存储的起始位置要从该成员大小的整数倍开始(比如int在32位机为4字节,则要从4的整数倍地址开始存储)。
原则2、结构体作为成员:如果一个结构里有某些结构体成员,则结构体成员要从其内部最大元素大小的整数倍地址开始存储。(struct a里存有struct b,b里有char,int,double等元素,那b应该从8的整数倍开始存储。)
原则3、收尾工作:结构体的总大小,也就是sizeof的结果,必须是其内部最大成员的整数倍,不足的要补齐。


这三个原则具体怎样理解呢?我们看下面几个例子,通过实例来加深理解。
  例1:struct{
  short a1;
  short a2;
  short a3;
  }A;


  struct{
  long a1;
  short a2;
  }B;


  sizeof(A) = 6; 这个很好理解,三个short都为2。
  sizeof(B) = 8; 这个比是不是比预想的大2个字节?long为4,short为2,整个为8,因为原则3。


  例2:struct A{
  int a;
  char b;
  short c;
  };


  struct B{
  char b;
  int a;
  short c;
  };


struct C{
  char b;
  short c;
int a;
  };


  sizeof(A) = 8; int为4,char为1,short为2,这里用到了原则1和原则3。
  sizeof(B) = 12; 是否超出预想范围?char为1,int为4,short为2,怎么会是12?还是原则1和原则3。


  深究一下,为什么是这样,我们可以看看内存里的布局情况。


  a b c
  A的内存布局:1111, 1*, 11


  b a c
  B的内存布局:1***, 1111, 11**


  其中星号*表示填充的字节。A中,b后面为何要补充一个字节?因为c为short,其起始位置要为2的倍数,就是原则1。c的后面没有补充,因为b和c正好占用4个字节,整个A占用空间为4的倍数,也就是最大成员int类型的倍数,所以不用补充。


  B中,b是char为1,b后面补充了3个字节,因为a是int为4,根据原则1,起始位置要为4的倍数,所以b后面要补充3个字节。c后面补充两个字节,根据原则3,整个B占用空间要为4的倍数,c后面不补充,整个B的空间为10,不符,所以要补充2个字节。


  再看一个结构中含有结构成员的例子:


  例3:struct A{
  int a;
  double b;
  float c;
  };


  struct B{
  char e[2];
  int f;
  double g;  
  short h;
  struct A i;
  };


  sizeof(A) = 24; 这个比较好理解,int为4,double为8,float为4,总长为8的倍数,补齐,所以整个A为24。
  sizeof(B) = 48; 看看B的内存布局。


  e f g h i 
  B的内存布局:11* *, 1111, 11111111, 11 * * * * * *, 1111* * * *, 11111111, 1111 * * * *  


  i其实就是A的内存布局。i的起始位置要为24的倍数,所以h后面要补齐。把B的内存布局弄清楚,有关结构体的对齐方式基本就算掌握了。


  以上讲的都是没有#pragma pack宏的情况,如果有#pragma pack宏,对齐方式按照宏的定义来。比如上面的结构体前加#pragma pack(1),内存的布局就会完全改变。sizeof(A) = 16; sizeof(B) = 32;


  有了#pragma pack(1),内存不会再遵循原则1和原则3了,按1字节对齐。没错,这不是理想中的没有内存对齐的世界吗。


  a b c
  A的内存布局:1111, 11111111, 1111


  e f g h i 
  B的内存布局:11, 1111, 11111111, 11 , 1111, 11111111, 1111  


  那#pragma pack(2)的结果又是多少呢?#pragma pack(4)呢?留给大家自己思考吧,相信没有问题。






【位结构体】




  还有一种常见的情况,结构体中含位域字段。
位域成员不能单独被取sizeof值。C99规定int、unsigned int和bool可以作为位域类型,但编译器几乎都对此作了扩展,允许其它类型类型的存在。


  使用位域的主要目的是压缩存储,其大致规则为: 
  1) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字段将紧邻前一个字段存储,直到不能容纳为止; 
  2) 如果相邻位域字段的类型相同,但其位宽之和大于类型的sizeof大小,则后面的字段将从新的存储单元开始,其偏移量为其类型大小的整数倍; 
  3) 如果相邻的位域字段的类型不同,则各编译器的具体实现有差异,VC6采取不压缩方式,Dev-C++采取压缩方式; 
  4) 如果位域字段之间穿插着非位域字段,则不进行压缩; 
  5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。


  还是让我们来看看例子。


  例4:struct A{ 
  char f1 : 3; 
  char f2 : 4; 
  char f3 : 5; 
  }; 


  a b c
  A的内存布局:111, 1111 *, 11111 * * *


  位域类型为char,第1个字节仅能容纳下f1和f2,所以f2被压缩到第1个字节中,而f3只能从下一个字节开始。因此sizeof(A)的结果为2。


  例5:struct B{ 
  char f1 : 3; 
  short f2 : 4; 
  char f3 : 5; 
  };


  由于相邻位域类型不同,在VC6中其sizeof为6,在Dev-C++中为2。


  例6:struct C{ 
  char f1 : 3; 
  char f2; 
  char f3 : 5; 
  };


  非位域字段穿插在其中,不会产生压缩,在VC6和Dev-C++中得到的大小均为3。




  考虑一个问题,为什么要设计内存对齐的处理方式呢?如果体系结构是不对齐的,成员将会一个挨一个存储,显然对齐更浪费了空间。那么为什么要使用对齐呢?体系结构的对齐和不对齐,是在时间和空间上的一个权衡。对齐节省了时间。假设一个体系结构的字长为w,那么它同时就假设了在这种体系结构上对宽度为w的数据的处理最频繁也是最重要的。它的设计也是从优先提高对w位数据操作的效率来考虑的。有兴趣的可以google一下,人家就可以跟你解释的,一大堆的道理。


  最后顺便提一点,在设计结构体的时候,一般会尊照一个习惯,就是把占用空间小的类型排在前面,占用空间大的类型排在后面,这样可以相对节约一些对齐空间。


位结构体
位结构 节省存贮空间 “:”操作符 位域


一、首先说概念:


位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构比按位运算符更加方便。
位结构定义的一般形式为:
struct  位结构名{
数据类型 [变量名]: 整型常数; //成员称为“位域”或者“位段”
数据类型 [变量名]: 整型常数;
} 位结构变量;


其中: 数据类型必须是整型(int/char/short)。 整型常数的范围是数据类型的长度, 如定义为short,则范围是1~16。
变量名是选择项, 可以不命名, 这样规定是为了排列需要。
例如: 下面定义了一个位结构。
struct webpage{
unsigned char incon: 8; /*incon占用低字节的0~7共8位*/
unsigned char txcolor: 4;/*txcolor占用高字节的0~3位共4位*/
unsigned char bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/
unsigned char blink: 1; /*blink占用高字节的第7位*/
}ch;
printf("%d\n",sizeof(struct webpage));输出:2。
位结构成员的访问与结构成员的访问相同。
例如: 访问上例位结构中的bgcolor成员可写成:
ch.bgcolor


注意:
1. 一个位域必须存储在定义它的一个数据类型内部,不能跨跨该数据类型。如char定义的位域所剩空间不够存放另一位域时,应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。
struct bs
{
 unsigned a:4
 unsigned :0 /*空域*/
 unsigned b:4 /*从下一单元开始存放*/
 unsigned c:4
}
在这个位域定义中,a占第一字节的4位,后4位填0表示不使用,b从第二字节开始,占用4位,c占用4位。


2.由于位域不允许越过定义它的数据类型,因此位域的长度不能大于定义它的数据类型的长度。
3. 位结构总长度(位数), 是各个位成员定义的位数之和再向最大结构成员对齐。
4. 位结构成员可以与其它结构成员一起使用。
例如:
struct info{
char name[8];
int age;
struct addr address;
float pay;
unsigned char state: 1;
unsigned char pay: 1;
}workers;
上例的结构定义了关于一个工人的信息。其中有两个位结构成员, 每个位结构成员只有一位, 用unsigned char数据类型,因此只占一个字节但保存了两个信息, 该字节中第一位表示工人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。


二、再说说位结构的位域存储顺序问题


我们知道字节存储顺序有高字节优先的big-endian大端存储法(高字节数据放在低字节地址处)和低字节优先的little-endian小端存储法,无论使用大端法还是小端法,都不存在技术原因,只是涉及到处理器厂商的立场和习惯。INTEL的X86平台使用小端法,IBM、 Motorola、Sun Microsystem的大多数微处理器则使用大端法,还有部分微处理器可以由用户自己设置是使用大端法还是小端法,如ARM、MIPS、PowerPC 等。
位域在存储时的顺序和它的编译器有关,一般是先申请的放在低位。程序举例如下:
#i nclude "stdio.h"
void main()
{
 union
 {
 struct student
 {
  unsigned char s1:1;
   unsigned char s2:3;
 }x;
 unsigned char c;
 }v;
 v.c=0;
 v.x.s1=0;
 v.x.s2=4;
printf("%d\n",v.c);
printf("%d\n",sizeof(struct student)); 
}
输出:
8
1


即结构体成员申请是按照顺序从低地址开始。所以上边结构体v在内存中数据的排列顺序为


    s1 s2
    |0| 0|0|1| 0|0|0|0| (1个字节,因为是unsigned char类型)
低地址       高地址




s1放着0
s2放着4(二进制100),在内存里由低到高为“|0|0|1|”。
所以v.c为二进制00001000,即十进制8。
同时,因为s1占一个位,s2占三个位,而两者都是unsigned char型,且最大的数据类型也就是unsigned char型,一个字节足够放下s1和s2了。所以我们看到struct student的大小为1个字节。
如果从先申请的放在高字节,则上边的输出为
           s2  s1
0000 |001 |0
即输出应该是:
64
1
网上有人说TURBO C是采用这种方式,我没试过。


三、位结构的位对齐问题
位结构的其实不存在位对齐问题,即位不需要对齐。其他方面,位结构和一般结构体类似,遵循结构体的对齐原则,


#i nclude "stdio.h"


void main()
{
 union
 {
 struct student
 {
  unsigned char s1:1;
   unsigned char s2:2;
  unsigned char s3:2;
 }x;
 unsigned char c;
 }v;
 v.c=0;
 v.x.s1=0;
 v.x.s3=2;
printf("%d\n",v.c);
printf("%d\n",sizeof(struct student)); 
}
输出结果是:
16
1


因为它只按整体对齐,所以为
s1s2s3
0  0001000
即二进制00010000等于十进制16,而不是
s1s2    s3
0  00 0 01 00


再举一个位结构体的例子


#i nclude "stdio.h"
void main()
{
 union
 {
 struct student
 {
  unsigned char s1:1;
   unsigned char s2:2;
  unsigned short s3:2;
 }x;
 unsigned short c;
 unsigned int d;
 }v;
 v.d=0;
 v.x.s1=0;
 v.x.s3=2;
printf("%d\n",v.d);
printf("%d\n",sizeof(struct student)); 
}
输出为:
131072
4


131072=(10 00000000 00000000)b
因为遵循结构体对齐原则,s3跳过了2个字节。
s1s2                               s3
0  00 00000| 00000000| 01

原创粉丝点击