位域是什么？
* k7 j$ h; w* h! _2 C% k  f
有些数据在存储时并不需要占用一个完整的字节，只需要占用一个或几个二进制位即可。例如开关只有通电和断电两种状态，用 0 和 1 表示足以，也就是用一个二进位。正是基于这种考虑，C语言又提供了一种叫做位域的数据结构。
在结构体定义时，我们可以指定某个成员变量所占用的二进制位数（Bit），这就是位域。请看下面的例子：
2 R0 b: j" g  L% y1 n. s1struct bs{
2    unsigned m;
6 D# S4 i# z9 ^" a2 E3    unsigned n: 4;
4    unsigned char ch: 6;
5};
:后面的数字用来限定成员变量占用的位数。成员 m 没有限制，根据数据类型即可推算出它占用 4 个字节（Byte）的内存。成员 n、ch 被:后面的数字限制，不能再根据数据类型计算长度，它们分别占用 4、6 位（Bit）的内存。
# H0 C! s2 u' K5 s' v1 A# Kn、ch 的取值范围非常有限，数据稍微大些就会发生溢出，请看下面的例子：
  ?# {: d% {) v: Q5 N, D 1#include <stdio.h>
; \+ `; c# J& f' L 2int main(){
+ W1 F: b. E# A$ q6 R  Z 3    struct bs{
4        unsigned m;
5        unsigned n: 4;
6        unsigned char ch: 6;
' n: R* q* \8 `& \9 q1 }7 `' F 7    } a = { 0xad, 0xE, '$'};
8    //第一次输出
5 Y1 B  K6 s; g9 |8 [' K" B+ B 9    printf("%#x, %#x, %c\n", a.m, a.n, a.ch);
: D- l" B* Y: M10    //更改值后再次输出
3 u. K# Y) G. q11    a.m = 0xb8901c;
12    a.n = 0x2d;
13    a.ch = 'z';
) j- K2 a1 ~6 y; }# G14    printf("%#x, %#x, %c\n", a.m, a.n, a.ch);
15    system("pause");
2 Z6 w: K. ]; R+ @* H3 L16    return 0;
) m* t7 E6 S! \. ]+ J( C- o17}
$ q' M' d5 k  p" Y* L$ l运行结果：
# k, A7 b  Q8 R8 h% B3 C- f
! x# J6 M# o# q1 s对于 n 和 ch，第一次输出的数据是完整的，第二次输出的数据是残缺的。
( X( h$ Q- ]) X1 O, _) x第一次输出时，n、ch 的值分别是 0xE、0x24（'$' 对应的 ASCII 码为 0x24），换算成二进制是1110、10 0100，都没有超出限定的位数，能够正常输出。
- m+ |5 S) f& a0 u3 c$ Z4 U  W第二次输出时，n、ch 的值变为 0x2d、0x7a（'z' 对应的 ASCII 码为 0x7a），换算成二进制分别是 10 1101、111 1010，都超出了限定的位数。超出部分被直接截去，剩下 1101、11 1010，换算成十六进制为 0xd、0x3a（0x3a 对应的字符是 :）。

C语言标准规定，位域的宽度不能超过它所依附的数据类型的长度。通俗地讲，成员变量都是有类型的，这个类型限制了成员变量的最大长度，:后面的数字不能超过这个长度。

例如上面的 bs，n 的类型是 unsigned int，长度为 4 个字节，共计 32 位，那么 n 后面的数字就不能超过 32；ch 的类型是 unsigned char，长度为 1 个字节，共计 8 位，那么 ch 后面的数字就不能超过 8。
我们可以这样认为，位域技术就是在成员变量所占用的内存中选出一部分位宽来存储数据。

C语言标准还规定，只有有限的几种数据类型可以用于位域。在 ANSI C 中，这几种数据类型是 int、signed int 和 unsigned int（int 默认就是 signed int）；到了 C99，_Bool 也被支持了。

但编译器在具体实现时都进行了扩展，额外支持了 char、signed char、unsigned char 以及 enum 类型，所以上面的代码虽然不符合C语言标准，但它依然能够被编译器支持。
6 q- h# p( T3 ?9 a; ]1 V; {; T

* \4 P" w+ K% @位域的存储
5 z" g/ [4 L0 ~% y& \) ]9 t0 @C语言标准并没有规定位域的具体存储方式，不同的编译器有不同的实现，但它们都尽量压缩存储空间。

; u9 D( I% P- m7 e, N8 A  m
! y* ]$ _& I7 o  v; G位域的具体存储规则如下：

• 当相邻成员的类型相同时，如果它们的位宽之和小于类型的 sizeof 大小，那么后面的成员紧邻前一个成员存储，直到不能容纳为止；如果它们的位宽之和大于类型的 sizeof 大小，那么后面的成员将从新的存储单元开始，其偏移量为类型大小的整数倍。
  

以下面的位域 bs 为例：
( S( n1 {( _" c: q 1#include <stdio.h>
3 j, r# s+ `8 m4 b( r, j# n 2int main(){
3    struct bs{
" E9 C! u+ _+ _! w 4        unsigned m: 6;
5        unsigned n: 12;
6        unsigned p: 4;
; w6 S; B/ K& ?6 F 7    };
8    printf("%d\n", sizeof(struct bs));
9    return 0;
10}
运行结果：
4 l. U/ X( E* I! @
m、n、p 的类型都是 unsigned int，sizeof 的结果为 4 个字节（Byte），也即 32 个位（Bit）。m、n、p 的位宽之和为6+12+4 = 22，小于 32，所以它们会挨着存储，中间没有缝隙。
4 c. U' m0 r# ?sizeof(struct bs)的大小之所以为 4，而不是 3，是因为要将内存对齐到 4 个字节，以便提高存取效率。
如果将成员 m 的位宽改为 22，那么输出结果将会是 8，因为22+12 = 34，大于 32，n 会从新的位置开始存储，相对 m 的偏移量是 sizeof(unsigned int)，也即 4 个字节。
1 ~! v2 n' H/ Z) P) N9 T如果再将成员 p 的位宽也改为 22，那么输出结果将会是 12，三个成员都不会挨着存储。
2.当相邻成员的类型不同时，不同的编译器有不同的实现方案，GCC 会压缩存储，而 VC/VS 不会。
8 e: C) a# a2 \9 ~: B5 @请看下面的位域 bs：
1#include <stdio.h>
2int main(){
3    struct bs{
4        unsigned m: 12;
5        unsigned char ch: 4;
- a$ S4 J* U4 {' O; \4 w 6        unsigned p: 4;
7    };
8    printf("%d\n", sizeof(struct bs));
9    return 0;
10}
在 GCC 下的运行结果为 4，三个成员挨着存储；在 VC/VS 下的运行结果为 12，三个成员按照各自的类型存储（与不指定位宽时的存储方式相同）。
9 G) `' Z( i0 j- sm 、ch、p 的长度分别是 4、1、4 个字节，共计占用 9 个字节内存，为什么在 VC/VS 下的输出结果却是 12 呢？期待您的回复。
+ `- n6 u+ k, _3 y. ~4 w- X3.如果成员之间穿插着非位域成员，那么不会进行压缩。例如对于下面的 bs：
2 s+ l* B9 `" X0 H1struct bs{
( y' z" o/ n3 S6 `* S& F2    unsigned m: 12;
3 G4 X5 [7 ^& \% g8 L8 n3    unsigned ch;
4    unsigned p: 4;
+ v( q  i/ y1 y0 ~6 S; K) s6 L5};
, x/ q; @/ N. Q9 b在各个编译器下 sizeof 的结果都是 12。
! [& D: [/ h6 d. T通过上面的分析，我们发现位域成员往往不占用完整的字节，有时候也不处于字节的开头位置，因此使用&获取位域成员的地址是没有意义的，C语言也禁止这样做。地址是字节（Byte）的编号，而不是位（Bit）的编号。


+ i, C' j5 g$ V+ ?! A3 R, J/ {无名位域
位域成员可以没有名称，只给出数据类型和位宽，如下所示：
  u1 a6 E: W$ k. x; f* {2 @5 t: D; H1struct bs{
2    int m: 12;
3    int  : 20;  //该位域成员不能使用
4    int n: 4;
% r+ h' d+ [2 |; G5 ]; n3 r5};
无名位域一般用来作填充或者调整成员位置。因为没有名称，无名位域不能使用。
上面的例子中，如果没有位宽为 20 的无名成员，m、n 将会挨着存储，sizeof(struct bs) 的结果为 4；有了这 20 位作为填充，m、n 将分开存储，sizeof(struct bs) 的结果为 8。
! V: g0 S1 ]( d3 F5 \9 u6 m; W* e# X
% I2 p" g  F! e+ i7 Y$ e