C语言-位运算

目录

位和字节

二进制

1、十进制转二进制字符串的思路

2、二进制字符串转十进制的思路

3、示例代码

八进制

进制之间转换原则

具体代码

位逻辑运算符

对齐特性

位字段

---

位和字节

1字节（byte） = 8 比特（bit） 

注：这个字节与比特的关系是规定的，记住就好，通用于任何场景，容易混淆的是字长和字节，字长指的是cpu一次性能够运算的数据的位数，不同的计算机可能不一样，但是字节这个概念是恒久不变的。

一个英文字符和英文标点占用一个字节，一个中文字符和中文标点占用两个字节。

计算机中的位

　　二进制数系统中，每个0或1就是一个位(bit)，位是数据存储的最小单位。其中8 bit就称为一个字节（Byte）。计算机中的CPU位数指的是CPU一次能处理的最大位数，例如32位计算机的CPU一次最多能处理32位数据，计算机中的CPU位数也成为机器字长，和数据总线（CPU与内部存储器之间连接的用于传输数据的线的根数）的概念是统一的。

注：关于地址总线、数据总线、控制总线的概念与原理在另一篇博文里面来讲述。

比特
　　1) 计算机专业术语，是信息量单位，是由英文BIT音译而来。二进制数的一位所包含的信息就是一比特，如二进制数0101就是4比特。
　　2)二进制数字中的位，信息量的度量单位，为信息量的最小单位。数字化音响中用电脉冲表达音频信号，“1”代表有脉冲，“0”代表脉冲间隔。如果波形上每个点的信息用四位一组的代码表示，则称4比特，比特数越高，表达模拟信号就越精确，对音频信号信号还原能力越强。

---

二进制

十六进制（Hexadecimal）：在数学中是一种逢16进1的进位制。一般用数字0到9和字母A到F（或a~f）表示，其中:A~F表示10~15。

十进制（Decimal System）：每相邻的两个计数单位之间的进率都为十；十进制是中华民族的一项杰出创造，在世界数学史上有重要意义。著名的英国科学史学家李约瑟教授曾对中国商代记数法予以很高的评价，"如果没有这种十进制，就几乎不可能出现我们现在这个统一化的世界了"，李约瑟说："总的说来，商代的数字系统比同一时代的古巴比伦和古埃及更为先进更为科学。"

八进制（Octal）：一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1。一些编程语言中常常以数字0开始表明该数字是八进制。八进制的数和二进制数可以按位对应（八进制一位对应二进制三位），因此常应用在计算机语言中。

二进制（binary）：在数学和数字电路中指以2为基数的记数系统，以2为基数代表系统是二进位制的。这一系统中，通常用两个不同的符号0（代表零）和1（代表一）来表示。

在实际开发中，我们可以用0和1的字符串来表达信息，例如某设备有八个传感器，每个传感器的状态用1表示正常，用0表示故障，用一个二进制的字符串表示它们如01111011，用一个字符或整数表示它就是123。

1、十进制转二进制字符串的思路

1）把十进数除以2，记下余数（余数保存在字符串中），现用商除以2，再记下余数，如此循环，直到商为0。

2）把保存余数的字符串反过来，就是结果。

例如123转化成二进制：

123/2=61余1

61/2=30余1

30/2=15余0

15/2=7余1

7/2=3余1

3/2=1余1

1/1=0余1

结果是1101111，反过来就是1111011。

2、二进制字符串转十进制的思路

把二进制字符串从最高位（左边第一位）开始用商乘以2再加余数（该位的数字），如此循环，左边第一位的商肯定是0。

例如1111011转化成十进制：

0*2+1=1

1*2+1=3

3*2+1=7

7*2+1=15

15*2+0=30

30*2+1=61

61*2+1=123

结果是123。

3、示例代码

/*
 * 程序名：book.c，此程序演示十进制和二进制的互相转换。
 * 作者：C语言技术网(www.freecplus.net) 日期：20190525。
*/
#include "stdio.h"
#include <string.h>
 
// 把十进制整数转换为二进制的字符串。
// dec：待转换的十进制整数。
// pbin：用于存放转换后的字符串的地址，注意，您必须保证pbin足以存放转换后的结果，否则可能会产生内存溢出。在64位操作系统中，long的最大取值为2的64次方，所以，pbin最大不必超过65。
void dectobin(const long dec,char *pbin)
{
  long ys=0;  // 余数。
  int s=dec;  // 商。
  int ii=0;   // 位数的计数器。
  char result[65];  // 十进制转换成二进制后，保存在result中，再反过来存放到pbin中。
 
  memset(result,0,sizeof(result));
 
  // 把十进制转换为二进制，存放在result中。
  while (s>0)
  {
    ys=s%2;
    s=s/2;
    result[ii]=ys+'0';
    ii++;
  }
  
  // 再把result字符串反过来，存放在pbin中。
  int jj=0;
  for (;ii>0;ii--)
  {
    pbin[jj]=result[ii-1];
    jj++;
  }
 
  pbin[jj]=0; // 出于安全的考虑，加上0表示字符串结束。
}
 
// 把二进制字符串转换为十进制。
// pbin：待转换的二进制字符串。
// 返回值：二进制字符串转换为十进制整数的结果。
long bintodec(const char *pbin)
{
  int ii=0;
  long result=0;
 
  while (pbin[ii]!=0)
  {
    result=result*2+(pbin[ii]-'0');
    ii++;
  }
 
  return result;
}
 
int main()
{
  int ii=0;
  printf("请输入一个整数：");  
  scanf("%d",&ii);
 
  char str[65];
  dectobin(ii,str);  // 把十进制转换为二进制的字符串。
  printf("%d的二进制输出是：%s\n",ii,str);
 
  // 再把二进制字符串转换为十进制。
  printf("%s转换为十进制的结果是：%d\n",str,bintodec(str));
}

运行测试：

 

---

八进制

进制之间转换原则

转换原则：不同进制之间的转换本质就是确定各个不同权值位置上的数码。转换正整数的进制的有一个简单算法，就是通过用目标基数作长除法；余数给出从最低位开始的“数字”

基于上述原则详细解释十进制转换成二进制：

十进制整数部分转换：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

十进制小数部分转换：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。

具体代码

#include 
#define BASE_SIZE 32
#define HEX 16
 
int binary_conversion( int value_t , int target_system_t )
{
  int value = value_t;
  int target_system = target_system_t;
  int target_value [BASE_SIZE] = {0};
  int target_value_i = 0;
  while( value )
  {
   target_value[target_value_i] = value % target_system; 
   value = value / target_system;
   target_value_i++;
  }
 
    if( target_system == HEX )
    {
        for( ; target_value_i >= 0; target_value_i-- )
	    {
		  printf( "%x", target_value[target_value_i] );
	    }
    }else{
	    for( ; target_value_i >= 0; target_value_i-- )
	    {
		  printf( "%d", target_value[target_value_i] );
	    }
	}
	return 0;
}
 
int mian( void )
{
    int input_value = 0; 
    int target_system = 0;
    scanf( "%d,%d", &input_value, &target_system ); 
    binary_conversion( input_value, target_system );
    return 0;
}

int binary_conversion( int value_t , int target_system_t )函数就是实现十进制与其他进制数之间的转换，输入参数value_t就是需要转换的数值， 输入参数target_system_t 就是需要把十进制转换为哪种进制数。

---

位逻辑运算符

与运算：&
两者都为1为1，否则为0

1&1=1,  1&0=0,  0&1=0,  0&0=0

或运算：|
两者都为0为0，否则为1
1|1 = 1,  1|0 = 1,  0|1 = 1, 0|0 = 0

非运算：~
1取0，0取1
~1 = 0, ~0 = 1
~(10001) = 01110

异或运算
两者相等为0,不等为1
1^1=0, 1^0=1, 0^1=1, 0^0=0

下面是详细的解释：

位运算

    位运算的运算分量只能是整型或字符型数据，位运算把运算对象看作是由二进位组成的位串信息，按位完成指定的运算，得到位串信息的结果。

位运算符有：

    &(按位与)、|(按位或)、^(按位异或)、~ (按位取反)。
    其中，按位取反运算符是单目运算符，其余均为双目运算符。
    位运算符的优先级从高到低，依次为~、&、^、|，
    其中~的结合方向自右至左，且优先级高于算术运算符，其余运算符的结合方向都是自左至右，且优先级低于关系运算符。

   (1)按位与运算符(&)

    按位与运算将两个运算分量的对应位按位遵照以下规则进行计算：
     0 & 0 = 0, 0 & 1 = 0, 1 & 0 = 0, 1 & 1 = 1。
即同为 1 的位，结果为 1，否则结果为 0。
    例如，设3的内部表示为
     00000011
    5的内部表示为
     00000101
    则3&5的结果为
     00000001
    按位与运算有两种典型用法，一是取一个位串信息的某几位，如以下代码截取x的最低7位：x & 0177。二是让某变量保留某几位，其余位置0，如以下代码让x只保留最低6位：x = x & 077。以上用法都先要设计好一个常数，该常数只有需要的位是1，不需要的位是0。用它与指定的位串信息按位与。

   (2)按位或运算符(|)

    按位或运算将两个运算分量的对应位按位遵照以下规则进行计算：
     0 | 0 = 0, 0 | 1 = 1, 1 | 0 = 1, 1 | 1 = 1
即只要有1个是1的位，结果为1，否则为0。
    例如，023 | 035 结果为037。
    按位或运算的典型用法是将一个位串信息的某几位置成1。如将要获得最右4为1，其他位与变量j的其他位相同，可用逻辑或运算017|j。若要把这结果赋给变量j，可写成：
     j = 017|j

   (3)按位异或运算符(^)

    按位异或运算将两个运算分量的对应位按位遵照以下规则进行计算：
     0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 0 = 1, 1 ^ 1 = 0
即相应位的值相同的，结果为 0，不相同的结果为 1。
    例如，013^035结果为026。
    异或运算的意思是求两个运算分量相应位值是否相异，相异的为1，相同的为0。按位异或运算的典型用法是求一个位串信息的某几位信息的反。如欲求整型变量j的最右4位信息的反，用逻辑异或运算017^j，就能求得j最右4位的信息的反,即原来为1的位，结果是0,原来为0的位，结果是1。

   (4)按位取反运算符(~)

    按位取反运算是单目运算，用来求一个位串信息按位的反，即哪些为0的位，结果是1，而哪些为1的位，结果是0。例如, ~7的结果为0xfff8。

    取反运算常用来生成与系统实现无关的常数。如要将变量x最低6位置成0，其余位不变，可用代码x = x & ~077实现。以上代码与整数x用2个字节还是用4个字节实现无关。

    当两个长度不同的数据进行位运算时(例如long型数据与int型数据)，将两个运算分量的右端对齐进行位运算。如果短的数为正数，高位用0补满；如果短的数为负数，高位用1补满。如果短的为无符号整数，则高位总是用0补满。

    位运算用来对位串信息进行运算，得到位串信息结果。如以下代码能取下整型变量k的位串信息的最右边为1的信息位：((k-1)^k) & k。

移位运算

    移位运算用来将整型或字符型数据作为二进位信息串作整体移动。有两个运算符：
     << (左移) 和 >> (右移)
移位运算是双目运算，有两个运算分量,左分量为移位数据对象，右分量的值为移位位数。移位运算将左运算分量视作由二进位组成的位串信息,对其作向左或向右移位，得到新的位串信息。
    移位运算符的优先级低于算术运算符，高于关系运算符，它们的结合方向是自左至右。
   (1)左移运算符(<<)
    左移运算将一个位串信息向左移指定的位，右端空出的位用0补充。例如014<<2,结果为060,即48。
    左移时，空出的右端用0补充，左端移出的位的信息就被丢弃。在二进制数运算中，在信息没有因移动而丢失的情况下，每左移1位相当于乘2。如4 << 2，结果为16。
   (2)右移运算符(>>)
    右移运算将一个位串信息向右移指定的位，右端移出的位的信息被丢弃。例如12>>2,结果为3。与左移相反，对于小整数，每右移1位，相当于除以2。在右移时，需要注意符号位问题。对无符号数据，右移时，左端空出的位用0补充。对于带符号的数据，如果移位前符号位为0(正数)，则左端也是用0补充；如果移位前符号位为1(负数)，则左端用0或用1补充，取决于计算机系统。对于负数右移，称用0 补充的系统为“逻辑右移”，用1补充的系统为“算术右移”。以下代码能说明读者上机的系统所采用的右移方法：
     printf("%d\n\n\n", -2>>4);
若输出结果为-1，是采用算术右移；输出结果为一个大整数，则为逻辑右移。
    移位运算与位运算结合能实现许多与位串运算有关的复杂计算。设变量的位自右至左顺序编号，自0位至15位，有关指定位的表达式是不超过15的正整数。以下各代码分别有它们右边注释所示的意义：
     ~（~0 << n）
     (x >> (1 p-n)) & ~(~0 << n)
     new |= ((old >> row) & 1) << (15 – k)
     s &= ~(1 << j)
     for(j = 0; ((1 << j) & s) == 0; j ) ;
===================================================================================================
位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。

C语言提供的位运算符列表：

运算符 含义 描述
& 按位与 如果两个相应的二进制位都为1，则该位的结果值为1，否则为0
| 按位或 两个相应的二进制位中只要有一个为1，该位的结果值为1
^ 按位异或 若参加运算的两个二进制位值相同则为0，否则为1
~ 取反 ~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0
<< 左移用来将一个数的各二进制位全部左移N位，右补0
>> 右移将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0

1、“按位与”运算符（&）

    按位与是指：参加运算的两个数据，按二进制位进行“与”运算。如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。这里的1可以理解为逻辑中的true,0可以理解为逻辑中的false。按位与其实与逻辑上“与”的运算规则一致。逻辑上的“与”，要求运算数全真，结果才为真。若，A=true,B=true,则A∩B=true 例如：3&5 3的二进制编码是11(2)。（为了区分十进制和其他进制，本文规定，凡是非十进制的数据均在数据后面加上括号，括号中注明其进制，二进制则标记为2）内存储存数据的基本单位是字节（Byte），一个字节由8个位（bit)所组成。位是用以描述电脑数据量的最小单位。二进制系统中，每个0或1就是一个位。将11（2）补足成一个字节，则是00000011（2）。5的二进制编码是101（2），将其补足成一个字节，则是00000101（2）
按位与运算：
00000011(2)
&00000101(2)
00000001(2)
由此可知3&5=1
c语言代码：
#include
main()
{
int a=3;
int b = 5;
printf("%d",a&b);
}
按位与的用途：
（1）清零
若想对一个存储单元清零，即使其全部二进制位为0，只要找一个二进制数，其中各个位符合一下条件：

原来的数中为1的位，新数中相应位为0。然后使二者进行&运算，即可达到清零目的。
例：原数为43，即00101011（2），另找一个数，设它为148，即10010100（2），将两者按位与运算：
00101011（2）
&10010100（2）
00000000（2）
c语言源代码：
#include
main()
{
int a=43;
int b = 148;
printf("%d",a&b);
}
（2）取一个数中某些指定位
若有一个整数a(2byte),想要取其中的低字节，只需要将a与8个1按位与即可。
a 00101100 10101100
b 00000000 11111111
c 00000000 10101100
（3）保留指定位：
与一个数进行“按位与”运算，此数在该位取1.
例如：有一数84，即01010100（2），想把其中从左边算起的第3，4，5，7，8位保留下来，运算如下：
01010100(2)
&00111011(2)
00010000(2)
即：a=84,b=59
    c=a&b=16

c语言源代码：
#include
main()
{
int a=84;
int b = 59;
printf("%d",a&b);
}

2、“按位或”运算符（|）

两个相应的二进制位中只要有一个为1，该位的结果值为1。借用逻辑学中或运算的话来说就是，一真为真

。
例如：60（8）|17（8）,将八进制60与八进制17进行按位或运算。
00110000
|00001111
00111111 
c语言源代码：
#include
main()
{
int a=060;
int b = 017;
printf("%d",a|b);
}
应用：按位或运算常用来对一个数据的某些位定值为1。例如：如果想使一个数a的低4位改为1，则只需要将a与17（8）进行按位或运算即可。

３、交换两个值，不用临时变量

例如：ａ＝３，即11（2）；ｂ＝４，即100（2）。
想将ａ和ｂ的值互换，可以用以下赋值语句实现：
    ａ＝a∧b;
    ｂ＝b∧a;
    ａ＝a∧b;
ａ＝011(2)
    （∧）ｂ＝100(2)
ａ＝111(2)（a∧b的结果，a已变成７）
    （∧）ｂ＝100(2)
ｂ＝011(2)（b∧a的结果，b已变成３）
    （∧）ａ＝111(2)

ａ＝100（2）（a∧b的结果，a已变成４）
等效于以下两步：
    ① 执行前两个赋值语句：“ａ＝ａ∧ｂ；”和“ｂ＝ｂ∧ａ；”相当于b=b∧(a∧b)。
    ② 再执行第三个赋值语句： ａ＝ａ∧ｂ。由于a的值等于（ａ∧ｂ），b的值等于（ｂ∧ａ∧ｂ），

因此，相当于a=ａ∧ｂ∧ｂ∧ａ∧ｂ，即a的值等于ａ∧ａ∧ｂ∧ｂ∧ｂ，等于ｂ。
很神奇吧！
c语言源代码：
 

复制代码代码如下:

#include  
main() 
{ 
int a=3; 
int b = 4; 
a=a^b; 
b=b^a; 
a=a^b; 
printf("a=%d b=%d",a,b); 
}

4、“取反”运算符（~）

他是一元运算符，用于求整数的二进制反码，即分别将操作数各二进制位上的1变为0，0变为1。
例如：~77(8)
源代码：
#include
main()
{
int a=077;
printf("%d",~a);
}

5、左移运算符（<<）

左移运算符是用来将一个数的各二进制位左移若干位，移动的位数由右操作数指定（右操作数必须是非负

值），其右边空出的位用0填补，高位左移溢出则舍弃该高位。
例如：将a的二进制数左移2位，右边空出的位补0，左边溢出的位舍弃。若a=15,即00001111（2），左移2

位得00111100（2）。
源代码：
#include
main()
{
int a=15;
printf("%d",a<<2);
}
左移1位相当于该数乘以2，左移2位相当于该数乘以2*2＝4,15＜＜2=60，即乘了４。但此结论只适用于该

数左移时被溢出舍弃的高位中不包含1的情况。
    假设以一个字节（８位）存一个整数，若ａ为无符号整型变量，则ａ＝64时，左移一位时溢出的是0

，而左移2位时，溢出的高位中包含1。

6、右移运算符（>>）
右移运算符是用来将一个数的各二进制位右移若干位，移动的位数由右操作数指定（右操作数必须是非负

值），移到右端的低位被舍弃，对于无符号数，高位补0。对于有符号数，某些机器将对左边空出的部分

用符号位填补（即“算术移位”），而另一些机器则对左边空出的部分用0填补（即“逻辑移位”）。注

意：对无符号数,右移时左边高位移入0；对于有符号的值,如果原来符号位为0(该数为正),则左边也是移

入0。如果符号位原来为1(即负数),则左边移入0还是1,要取决于所用的计算机系统。有的系统移入0,有的

系统移入1。移入0的称为“逻辑移位”,即简单移位；移入1的称为“算术移位”。 
例： a的值是八进制数113755： 
   a:1001011111101101 （用二进制形式表示）
   a>>1: 0100101111110110 (逻辑右移时)
   a>>1: 1100101111110110 (算术右移时)
   在有些系统中,a>>1得八进制数045766,而在另一些系统上可能得到的是145766。Turbo C和其他一些C

编译采用的是算术右移,即对有符号数右移时,如果符号位原来为1，左面移入高位的是1。
源代码：
#include
main()
{
int a=0113755;
printf("%d",a>>1);
}

7、位运算赋值运算符

位运算符与赋值运算符可以组成复合赋值运算符。
   例如: &=, |=, >>=, <<=, ∧=
   例： a & = b相当于 a = a & b
         a << =2相当于a = a << 2

---

对齐特性

对齐指的是如何安排对象在内存中的位置。
_Alignof运算符给出了一个类型的对齐要求，在关键字_Aligof后面的圆括号中写上类型名即可：

size_t  d_align  = _Alignof(float);

假定d_align的值是4，意思float类型对象的对齐要求是4。较大的对齐值被称为stricter或stronger,较小的值被称为weaker.
可以使用_Alignas说明符指定一个变量或类型的对齐值，但是不应该要求该值小于基本对齐值。

_Alignas(double) char c1;
_Alignas(8) char c2;
unsigned char _Alignas(long double) c_arr[sizeof(long double)];

注意：

不同版本的要求不同，有的要求_Alignas(type)说明符在类型说明符的后面，有的在前面，无论哪一种都能够识别。

示例程序：

/*
 * @Author: wangyunlong
 * @Date:   2020-03-08 20:45:04
 * @Last Modified by:   Your name
 * @Last Modified time: 2020-03-08 21:11:28
 */
#include 
#include
#include
int main(void)
{
    double dx;
    char ca;
    char cx;
    double dz;
    char cb;
    char _Alignas(double) cz;
    printf("char alignment:   %zd\n", _Alignof(char));
    printf("double alignment:  %zd\n", _Alignof(double));
    printf("&dx: %p\n",&dx);
    printf("&ca: %p\n",&ca);
    printf("&cx: %p\n",&cx);
    printf("&dz: %p\n",&dz);
    printf("&cb: %p\n",&cb);
    printf("&cz: %p\n",&cz);
    getchar();
    getchar();
    return 0;   
}

运行结果：

char alignment:   1
double alignment:  8
&dx: 0061FF18
&ca: 0061FF17
&cx: 0061FF16
&dz: 0061FF08
&cb: 0061FF07
&cz: 0061FF00

 

---

位字段

位字段（bit filed）是C语言中一种存储结构，不同于一般结构体的是它在定义成员的时候需要指定成员所占的位数。位字段是一个signed int或unsigned int类型变量中一组相邻的位（C99和C11新增了Bool类型的位字段）。位字段通过一个结构声明来建立，该结构声明为每个字段提供标签，并确定该字段的宽度。例如，下面的声明建立了4个1位的字段：

struct {
 
    unsigned autfd : 1;
    unsigned bldfc : 1;
    unsigned undln : 1;
    unsigned itals : 1;
} prnt;

根据该声明，prnt包含了4个1位的字段。现在，可以通过普通的结构成员运算符（.）单独给这些字段赋值：

    prnt.itals=1;
    prnt.undln=0;
    prnt.bldfc=1;
    prnt.autfd=0;

下面查看一下prnt的值：

    char str[33];
    int* value=reinterpret_cast<int*>(&prnt);
    itoa(*value,str,2);
    printf("%d %d %d %d\n", prnt.autfd,prnt.bldfc,prnt.undln,prnt.itals);
    printf("sizeof(prnt) = %d\n",sizeof(prnt));
    printf("十进制: %d\n",prnt);
    printf("二进制: %032s\n",str);

输出的结果为：
0 1 0 1
sizeof(prnt) = 4
十进制： 10
二进制： 0000 0000 0000 0000 0000 0000 0000 1010

可以看出，prnt的大小为4个字节（unsigned int 或 signed int），通过prnt的结构成员可以设置和访问某些bit位的值。
带有位字段的结构提供了一种记录设置的方便途径。许多设置（如，字体的粗体或斜体）就是简单的二进制一。例如，开或关、真或假。如果只需要使用1位，就不需要使用整个变量。内含位字段的结构允许在一个存储单元中存储多个设置。
有时，某些设置也有多个选择，因此需要多位来表示。例如，可以使用如下代码：

struct{
    unsigned code1 : 2;
    unsigned code2 : 2;
    unsigned code3 : 8;
}prcode;

这里创建了两个2位的字段和一个8位的字段，可以这样赋值：

    prcode.code1=0;
    prcode.code2=3;
    prcode.code3=102;

但是要确保赋的值不超出字段可容纳的范围（下面会说明当超出范围时会发生什么事情）。

再次打印出prcode的内容

    int* value_prcode=reinterpret_cast<int*>(&prcode);
    itoa(*value_prcode,str,2);
    printf("%d %d %d\n",prcode.code1,prcode.code2,prcode.code3);
    printf("sizeof(prcode) = %d\n",sizeof(prcode));
    printf("十进制: %d\n",prcode);
    printf("二进制: %032s\n",str);

打印结果如下：
0 3 102
sizeof(prcode) = 4
十进制：1644
二进制：0000 0000 0000 0000 0000 0110 0110 1100

可以看出，prcode.code1对应于0-1比特位，数值为00，对应十进制为0；
prcode.code1对应于2-3比特位，数值为11，对应十进制为3；
prcode.code2对应于4-11比特位，数值为0110 0110，对应十进制为102。
因此，一个字段可以对应于多个比特位，且当使用结构字段赋值在可容纳的范围之内时，变量可以记录正确的值。

这里再讨论一些需要注意的问题。首先是，如果声明的总位数超过一个unsigned int类型的大小（4 bytes）时会发生什么事情？结果是会用到下一个unsigned int类型的存储位置。一个字段不允许跨越两个unsigned int之间的边界。编译器会自动移动跨界的字段，保持unsigned int的边界对齐。一旦发生这种情况，第1个unsigned int中会留下一个未命名的“洞”。例如：

struct{
    unsigned a : 4;
    unsigned b : 4;
    unsigned c : 4;
    unsigned d : 25;
}prlimit;

上面定义的位字段大小共37个bits，超过了一个unsigned int的范围，给prlimit的各结构成员赋值，并使用下面代码打印出prlimit所存储的内容：

    prlimit.a=0xF;
    prlimit.b=0;
    prlimit.c=0xF;
    prlimit.d=0x1FFFFFF;
 
    char str_1[33];
    char str_2[33];
    int* value_1=reinterpret_cast<int*>(&prlimit);
    int* value_2=reinterpret_cast<int*>(&prlimit)+1;
    itoa(*value_1,str_1,2);
    itoa(*value_2,str_2,2);
    printf("0x%x 0x%x 0x%x 0x%x \n",prlimit.a,prlimit.b,prlimit.c ,prlimit.d);
    printf("sizeof(prlimit) = %d\n",sizeof(prlimit));
    printf("二进制 0~31位: %032s\n",str_1);
    printf("二进制 32~63位: %032s\n",str_2);

输出的结果如下：
0xf 0x0 0xf 0x1ffffff
sizeof(prlimit) = 8
二进制 0-31位：0000 0000 0000 0000 0000 1111 0000 1111
二进制 32-63位：0000 0001 1111 1111 1111 1111 1111 1111

从输出的结果可以看出，首先，prlimit的大小为8个字节；其次，编译器强制prlimit.d字段发生边界对齐，即prlimit.d位于第二个unsigned int上，prlimit.c与prlimit.d之间会填充未命名的“洞”。

实际上，我们也可以人为的在结构体当中设置未命名的字段宽度来进行填充。使用一个宽度为0的未命名的字段迫使下一个字段与下一个整数对齐：

struct {
    unsigned field1 : 1;
    unsigned        : 2;
    unsigned field2 : 1;
    unsigned        : 0;
    unsigned field3 : 4;
} stuff;

使用下面的代码输出stuff的内容：

    stuff.field1=1;
    stuff.field2=1;
    stuff.field3=0xf;
    char str_1[33];
    char str_2[33];
    int *value_1=reinterpret_cast<int*>(&stuff);
    int *value_2=reinterpret_cast<int*>(&stuff)+1;
    itoa(*value_1,str_1,2);
    itoa(*value_2,str_2,2);
    printf("sizeof(stuff) = %d\n",sizeof(stuff));
    printf("二进制 0-31位: %032s\n",str_1);
    printf("二进制 32-63位: %032s\n",str_2);

输出的结果为：
sizeof(stuff) = 8
二进制 0-31位：0000 0000 0000 0000 0000 0000 0000 1001
二进制 32-63位： 0000 0000 0000 0000 0000 0000 0000 1111

也就是说，在这里，stuff.field1和stuff.field2之间，有一个2位的空隙；stuff.field3被强迫与下一个整数对齐，存储到下一个unsigned int中。stuff的大小为8个字节。

最后讨论一个当赋值超出字段可容纳范围的问题。

struct {
    unsigned t1 : 2;
    unsigned t2 : 3;
    unsigned t3 : 4;
} test;
 
int main(){
 
    test.t1=3;
    test.t3=0;
    test.t2=11;
    printf("%d %d %d\n",test.t1,test.t2,test.t3);
    int *value=reinterpret_cast<int*>(&test);
    char str[50];
    itoa(*value,str,2);
    printf("二进制：%032s\n",str);
 
    return 0;
 
}

输出的结果为：
3 3 0
二进制：0000 0000 0000 0000 0000 0000 0000 1111

上述代码中，成员test.t2赋值的大小超出了容纳的范围。可以看到，t2赋值为11(二进制是1011)，结果输出的值是3（二进制是011），即截断了超出的部分。同时也可以看到，超出的部分不会影响t3的值（不同平台不一样？网上有人说会覆盖超出的区域）。

最后需要说明的是，字段存储在一个int中的顺序取决于机器。在有些机器上，存储的顺序是从左往右的，而在另一些机器上，是从右往左的。另外，不同的机器中两个字段边界的位置也有区别。由于这些原因，位字段通常都不容易移植。尽管如此，有些情况却要用到这种不可移植的特性。例如，以特定硬件设备所用的形式存储数据。