C 语言位操作总结

C 语言位操作

c语言位操作 2009/12/16

一、位的概念 (2)

二、位逻辑运算符 (2)

1、& 操作符 (3)

（1）清除位：设置某位为0，而其他位保持不变。 (3)

（2）检测位 (3)

（3）保留变量的某一位 (3)

（4）与操作运算： (3)

2、| 操作符 (4)

3、^ 操作符 (4)

（1）翻转某一位 (4)

（2）保留原值 (5)

（3）交换两个变量的值，而不用临时变量 (5)

4、~ 操作符 (6)

（1）设定某些位为0，其他的位为1，而不管这个数据的大小。 (6)

（2）联合使用&操作符确保某些位一定被置0： (7)

三、位移运算符 (8)

1、左移运算符 (8)

2、右移运算符 (9)

五、位运算赋值运算符 (10)

六、不同长度的数据进行位运算 (11)

七、位域 (11)

八、c语言位操作的一些注意事项 (12)

1. 位操作尽量使用unsigned char (12)

2. 每次操作最好用括号括起来，不要随意猜想其算术优先级 (15)

C 语言位操作

C语言是一种中级语言，能对计算机硬件直接操作，这就涉及到位的概念。十六进制使用四个二进制位来表示从0到15的数字，这些数字也是单个的十六进制阿拉伯数字所能表示的范围。由四个二进制位或一个BYTE的一半组成的组被称为一个元组。一个BYTE包含两个元组，所以我们可以使用两个十六进制阿拉伯数字来表示一个BYTE类型的值。

一、位的概念

我们知道，在计算机中，一字节占8位(现在的某些电脑也有占16位的)，这样表示的数的范围为0-255，也即00000000-11111111。位就是里面的0和1。

char c=100;

实际上c应该是01100100，正好是64H。其中高位在前，低位在后。

二、位逻辑运算符

符号描述运算规则

&位逻辑与两个位都为1时，结果为1，否则为0；

|位逻辑或两个位都为0时，结果为0，否则为1；

^位逻辑异或当两个位相同时，结果为0，否则为1；

~ 取反当为1时结果为0，当为0时，结果为1

表中除去最后一个运算符是单目运算符，其他都是双目运算符。这些运算符只能用于整型表达式。位逻辑运算符通常用于对整型变量进行位的设置、清零、取反、以及对某些选定的位进行检测。在程序中一般被程序员用来作为开

C 语言位操作

关标志。较低层次的硬件设备驱动程序，经常需要对输入输出设备进行位操作。

1、& 操作符

这个操作符理想的应用是建立一个掩码来检查某个位的值。

（1）清除位：设置某位为0，而其他位保持不变。

c=c&0xBF;

这样c和10111111与以后，总能使第6位为0，其他位保持不变。

a=0xfe; //a=0b 11111110

a=a&0x55;//使变量a的第1位、第3位、第5位、第7位清零 a= 0b 01010100

（2）检测位

要知道一个变量中某一位是‘1’还是‘0’，可以使用与操作来实现。

a=0xf5; //a=0b 11110101

result=a&0x08; //检测a的第三位,result=0

（3）保留变量的某一位

要屏蔽某一个变量的其它位，而保留某些位，也可以使用与操作来实现。

a=0x55; //a=0b 01010101

a=a&0x0f; //将高四位清零，而保留低四位 a=0x05

（4）与操作运算：

那么如果参加运算的两个数为负数，又该如何算呢？会以其补码形式表示的二进制数来与运算。a=-5&-3; //a=(0b 1011) & (0b1101) =0b 1001 =-7

C 语言位操作

2、| 操作符

设置位：设置某位为1，而其他位保持不变，可以使用位逻辑或运算。

这个操作符的理想应用是确保某个位被设置。假设我们想某个值的位3一定被设置：

BYTE b = 50;

BYTE c = b | 0x04;

cout << "c = " << c << endl;

这会发生如下的计算：

b=00110010

| 00000100

= 00110110 =result

3、^ 操作符

异或运算符＾又被称为XOR运算符，比较两个数，只有这两个数的相应位标志不同时，返回数的相应位才会被设置1。

异或运算主要有以下几种应用：

（1）翻转某一位

当一个位与‘1’作异或运算时结果就为此位翻转后的值。如下例：a=0x35; //a=0b00110101

a=a^0x0f; //a=0b00111010 a的低四位翻转

关于异或的这一作用，有一个典型的应用，即取浮点的相反数，具体的实现下：

f=1.23; //f为浮点型变量值为1.23

C 语言位操作

f=f*-1; //f乘以-1，实现取其相反数，要进行一次乘运算

f=1.23;

((unsigned char *)&f)[0]^=0x80; //将浮点数f的符号位进行翻转实现取相反数

（2）保留原值

当一个位与‘0’作异或运算时，结果就为此位的值。如下例：

a=0xff; //a=0b11111111

a=a^0x0f; //a=0b11110000 与0x0f作异或，高四位不变，低四位翻

（3）交换两个变量的值，而不用临时变量

要交换两个变量的值，传统的方法都需要一个临时变量。实现如下：void swap(unsigned char *pa,unsigned char *pb)

{

unsigned char temp=*pa;//定义临时变量，将pa指向的变量值赋给它

*pa=*pb;

*pb=temp; //变量值对调

}

而使用异或的方法来实现，就可以不用临时变量，如下：

void swap_xor(unsigned char *pa,unsigned char *pb)

{

*pa=*pa^*pb;

*pb=*pa^*pb;

C 语言位操作

*pa=*pa^*pb; //采用异或实现变量对调

}

从上例中可以看到异或运算在开发中是非常实用和神奇的。

4、~ 操作符

（1）设定某些位为0，其他的位为1，而不管这个数据的大小。

假设除了位0和位1，我们想把其他的位置1：

BYTE b = ~0x03;

cout << "b = " << b << endl;

WORD w = ~0x03;

cout << "w = " << w << endl;

这会发生如下的计算：

00000011 - 0x03

11111100 - ~0x03 b

0000000000000011 - 0x03

1111111111111100 - ~0x03 w

对小于0的有符号整型变量取相反数

d=-1;

//d为有符号整型变量，赋值为-1，内存表示为0b 11111111 11111111

d=~d+1; //取d的相反数,d=1,内存表示0b 00000000 00000001 此例运用了负整型数在内存以补码方式来存储的这一原理来实现的。负数的补

码方式是这样的：负数的绝对值的内存表示取反加1，就为此负数的内存表

C 语言位操作

示。如-23如果为八位有符号整型数，则其绝对值23的内存表示为

0b00010111，对其取反则为0b11101000再加1为0b11101001，即为0XE9，与Keil仿真结果是相吻合的：

（2）联合使用&操作符确保某些位一定被置0：

BYTE b = 50;

cout << "b = " << b << endl;

BYTE c = b & ~0x10;

cout << "c = " << c << endl;

这会发生如下的计算：

00110010 - b

& 11101111 - ~0x10

----------

00100010 - result

“增强可移植性”

用以下实例来讲解：假如在一种单片机中unsigned char类型是八个位（1个字节），那么一个此型的变量a=0x67，对其最低位清零。则可以用以下方法：a=0x67; //a=0b 0110 0111

a=a&0xfe; //a=0b 0110 0110

上面的程序似乎没有什么问题，使用0xfe这一因子就可以实现一个unsigned char型的变量最低位清零。但如果在另一种单片机中的unsigned char类型被定义为16个位（两个字节），那么这种方法就会出错，如下：

C 语言位操作

b=0x6767; //假设b为另一种单片机中的unsigned char 类型变量，值为0b 0110

0111 0110 0111

b=b&0xfe; //如果此时因子仍为0xfe的话，则结果就为0b 0000 0000 0110 0110

0x0066，而与0x6766不相吻合

上例中的问题就是因为不同环境中的数据类型差异所造成的，即程序的可移植性不好。对于这种况可以采用如下方法来解决：

a=0x67; //a=0b 0110 0111

a=a&~1; //在不同的环境中~1将自动匹配运算因子，实现最后一位清零

a=0x66

其中~1为 0b 11111110

b=0x6767; //a=0b 0110 0111 0110 0111

b=a&~1; //~1=0b 1111 1111 1111 1110，b=0b 0110 0111 0110 0110 ，即0x6766

三、位移运算符

符号描述

<< 左移

>> 右移

1、左移运算符

左移运算符用来将一个数的各位全部向左移若干位。如：

C 语言位操作

a=a<<2

表示将a的各位左移2位，右边补0。如果a=34(0x22或0b00100010)，左移2位得0b10001000，即十的136。高位在左移后溢出，不起作用。

从上例可以看到，a被左移2位后，由34变为了136，是原来的4倍。而如果左移1位，就为0b01000100，即十进制的68，是原来的2倍，很显然，左移N位，就等乘以了2N。但一结论只适用于左移时被溢出的高位中不包含‘1’的情

况。比如

a=64; //a=0b 0100 0000

a=a<<2; //a=0b 0000 0000

其实可以这样来想，a为unsigned char型变量，值为64，左移2位后等于乘以了4，即64X4＝256，这种类型的变量在表达256时，就成为了0x00，产生了一个进位，即溢出了一个‘1’。

在作乘以2N这种操作时，如果使用左移，将比用乘法快得多。因此在程序中适应的使用左移，可以提高程序的运行效率。

2、右移运算符

右移与左移相类似，只是位移的方向不同。如：

a=a>>1

表示将a的各位向右移动1位。与左移相对应的，左移一位就相当于除以2，右移N位，就相当于除以2N。

对于左边移出的空位，如果是正数则空位补0，若为负数，可能补0或补1，这取决于所用的计算机系统。移入0的叫逻辑右移，移入1的叫算术右移，Turbo C采用逻辑右移。

如：d=-32; //d为有符号整型变量，值为-32，内存表示为0b 11100000 d=d>>1;//右移一位 d为 0b 11110000 即-16，Keil采用"算术逻辑"进行编译。

C 语言位操作

程序员常常对右移运算符来实现整数除法运算，对左移运算符来实现整数乘法运算。其中用来实现乘法和除法的因子必须是2的幂次。

3、举例

输入一个整数，判断这个数中有几个二进制位1？例如输入67，输出结果应该为3。因为67的相应二进制数为00000000 01000011(0043H)，有3个1出现。分析：要判断是不是1，只需要判断该位与1与以后是不是1就可以知道。一个整数，判断16次即可。

main()

{int num,k;

int count=0; /* 记录1的个数 */

scanf("%d",&num);

for(k=0;k<16;k++)

{if(num&1==1) count++; /* 判断最低位是不是1 */

num>>=1; /* num右移1位 */}

printf("%d\n",count);

}

这样每次都判断最低位是不是1，判断完以后，让前面的右移一位即可。

对位的操作，一般程序中用的不多，但是在对计算机硬件操作时，肯定会涉及到。例如，我们以后要讲到的对串口和声卡操作就要用到一些。

五、位运算赋值运算符

在对一个变量进行了位操作中，要将其结果再赋给该变量，就可以使用位算赋值运算符。位运算赋值运算符如下：

C 语言位操作

&=, |=,^=,~=,<<=, >>=

例如：a&=b相当于a=a&b,a>>=2相当于a>>=2。

六、不同长度的数据进行位运算

如果参与运算的两个数据的长度不同时，如a为char型，b为int型，则编译将二者按右端补齐。如果a为正数，则会在左边补满‘0’。若a为负数，左边补满‘1’。如果a为无符号整型，则左边会添满‘0’。

a=0x00; //a=0b 00000000

d=0xffff; //d=0b 11111111 11111111

d&=a; //a为无符号型，左边添0，补齐为0b 00000000 00000000，d=0b 00000000 00000000

七、位域

另一个可以使用位的有意思的事是使用位域。你可以使用位域在BYTE，WORD或DWORD内建立更小的结构。例如，假设我们想知道日期，但我们我想尽可能使用较少的内存。我们可以像下面这样建立数据结构：

struct date_struct {

BYTE day : 5, // 1 to 31

month : 4, // 1 to 12

year : 14; // 0 to 9999

} date;

在这个例子中，'日'占用了5个位，'月'占用了接下来的4位，同时'年'占用了接下来的14位。位24不用。如果我用整型定义每个域，这个结构将占用12字节。

C 语言位操作

|0 0 0 0 0 0 0 0|0 0 0 0 0 0 0 0|0 0 0 0 0 0 0 0|

| | | |

+------ year ---------------+ month +-- day --+

现在，注意它的声明部分，看我们做了什么。

首先，我们看我们对位域结构使用的数据类型。这里我们用了BYTE。一个BYTE占8位，编译器将分配一个BYTE来存贮数据。如果在结构里我们使用了超过了8位的空间，编译器将分配另外的8位BYTE，直到能容纳我们的结构为止。如果我们使用了WORD或DWORD，编译器将分配一个总共32位的空间容纳我们的结构。

现在，我们来看下不同的域是怎样声明的。首先，我们使用冒号分开域名和位数。既然我们能获得位域的地址，我们就能使用这个结构的地址。

date.day = 12;

dateptr = &date;

dateptr->year = 1852;

八、c语言位操作的一些注意事项

1. 位操作尽量使用unsigned char

如果你使用char，那么一个普通的字符，0xe3,因为首位是1，所以当他被转换为16位长时，成了0xffffffe3，而不是我们想要的0x000000e3，因为他是一个有符号的负数。

举例如下：

#include <stdlib.h>

#include <stdio.h>

C 语言位操作

int main()

{

// char buf[10] = {0};

unsigned char buf[10] = {0};

char sbuf[10] = {0};

buf[0] = 0xe3;

buf[1] = 0xb4;

sbuf[0] = 0xe3;

sbuf[1] = 0xb4;

unsigned short pid1, pid2, pid3;

/*bit operations with unsigned chars*/

printf("bit operations with unsigned chars:\n"); pid1= (buf[0]&0x1f);

pid2= ((buf[0]&0x1f)<<8);

pid3= ((buf[0]&0x1f)<<8)|buf[1];

printf( "pid1 = %x\n", pid1 );

printf( "pid2 = %2x\n", pid2 );

printf( "pid3 = %2x\n", pid3 );

C 语言位操作

/*bit operations with signed chars*/

printf("bit operations with signed chars:\n"); pid1= (sbuf[0]&0x1f);

pid2= ((sbuf[0]&0x1f)<<8);

pid3= ((sbuf[0]&0x1f)<<8)|sbuf[1];

printf( "pid1 = %x\n", pid1 );

printf( "pid2 = %2x\n", pid2 );

printf( "pid3 = %2x\n", pid3 );

}

结果如下：

[shaoting@serverbj6:/user/shaoting/DVB-T]$ ./a.out bit operations with unsigned chars:

pid1 = 3

pid2 = 300

pid3 = 3b4

C 语言位操作

bit operations with signed chars:

pid1 = 3

pid2 = 300

pid3 = ffb4

可见，pid3的两次取值，因为一个是针对unsigned char的buffer,另一个是针对char的buffer而使结果不同。

2. 每次操作最好用括号括起来，不要随意猜想其算术优先级

位操作的优先级比算数运算优先级低，如果记不清楚，就将其括起来，不要想当然，例子：

#include <stdlib.h>

#include <stdio.h>

int main()

{

unsigned char buf[10] = {0};

buf[0] = 0xf0;

buf[1] = 0x03;

unsigned short pid3, pid4;

pid3= 5+ ((buf[0]&0x0f)<<8)|buf[1];

pid4 =5+ (((buf[0]&0x0f)<<8)|buf[1]);

printf( "pid3 = %2x\n", pid3 );

printf( "pid4 = %2x\n", pid4 );

C 语言位操作

}

结果：

[shaoting@serverbj6:/user/shaoting/DVB-T]$ ./a.out

pid3 = 7

pid4 = 8

可见，我们以为pid3和pid4结果应该是一样的，都是8，但我们错了，pid3的计算结果其实是等于（5+ ((buf[0]&0x0f)<<8)）|buf[1]，即先进行了加法计算，在进行了位与计算。