单片机的C语言中位操作用法

单片机的C语言中位操作用法

在对单处机进行编程的过程中，对位的操作是经常遇到的。C51对位的操控能力是非常强大的。从这一点上，就可以看出C不光具有高级语言的灵活性，又有低级语言贴近硬件的特点。这也是在各个领域中都可以看到C的重要原因。在这一节中将详细讲解C51中的位操作及其应用。

1 、位运算符

C51 提供了几种位操作符，如下表所示：

运算符	含义	运算符	含义
&	按位与	~	取反
|	按位或	<<	左移
^	按位异或	>>	右移

1 ）“按位与”运算符（ & ）
参加运算的两个数据，按二进位进行“与”运算。原则是全 1 为 1, 有 0 为 0, 即：


0&0=0; 0&1=0; 1&0=0; 1&1=1;
如下例：

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

a=-5&-3; //a=(0b 1011) & (0b1101) =0b 1001 =-7
在实际的应用中与操作经常被用于实现特定的功能：

1. 清零
“按位与”通常被用来使变量中的某一位清零。如下例：

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
　 2 ）“按位或”运算符（｜） 　　　　　　　　　　　
　　　　　　参与或操作的两个位，只要有一个为‘ 1 ’，则结果为‘ 1 ’。即有‘ 1 ’为‘ 1 ’，全‘ 0 ’为‘ 0 ’。
　　　　　　　　　　　　　
0|0=0; 0|1=1; 1|0=1; 1|1=1;
例如：
　　　　　　　　 a=0x30|0x0f; //a=(0b00110000)|(0b00001111)=(0b00111111)=0x3f
“按位或”运算最普遍的应用就是对一个变量的某些位置‘ 1 ’ 。如下例：
a=0x00; //a=0b 00000000
a=a|0x7f; // 将a 的低7 位置为1,a=0x7f

3) “异或”运算符（＾）
　　　　　　异或运算符＾又被称为 XOR 运算符。当参与运算的两个位相同（‘ 1 ’与‘ 1 ’或‘ 0 ’与‘ 0 ’）时结果为‘ 0 ’。不同时为‘ 1 ’。即相同为 0 ，不同为 1 。
　　　　　
0^0=0; 0^1=1; 1^0=1;1^1=0;
例如：
　　　　　　　　 a=0x55^0x3f; //a=(0b01010101)^(0b00111111)=(0b01101010)=0x6a
异或运算主要有以下几种应用：
　　　　　　 1. 翻转某一位
　　　　　　　　　当一个位与‘ 1 ’作异或运算时结果就为此位翻转后的值。如下例：
a=0x35; //a=0b00110101
a=a^0x0f; //a=0b00111010
a 的低四位翻转
　　　　　　　　　关于异或的这一作用，有一个典型的应用，即取浮点的相反数，具体的实现如下：
f=1.23; //f 为浮点型变量　值为1.23
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;

*pa=*pa^*pb;
// 采用异或实现变量对调
}
从上例中可以看到异或运算在开发中是非常实用和神奇的。
　 4 ）“取反”运算符（ ~ ）
　　　　　　　　　与其它运算符不同，“取反”运算符为单目运算符，即它的操作数只有一个。它的功能就是对操作数按位取反。也就是是‘ 1 ’得‘ 0 ’，是‘ 0 ’得‘ 1 ’。
　　　　　　　　　　　　
~1=0; ~0=1;



如下例：
a=0xff; //a=0b11111111
a=~a; //a=0b00000000

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

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

d=~d+1; // 取d 的相反数,d=1, 内存表示0b 00000000 00000001 　　　　　　　　
　　此例运用了负整型数在内存以补码方式来存储的这一原理来实现的。负数的补码方式是这样的：负数的绝对值的内存表示取反加 1 ，就为此负数的内存表示。如 -23 如果为八位有符号整型数，则其绝对值 23 的内存表示为 0b00010111 ，对其取反则为 0b11101000 ，再加 1 为 0b11101001 ，即为 0XE9 ，与 Keil 仿真结果是相吻合的：

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

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

5 ）左移运算符（ << ）
　　左移运算符用来将一个数的各位全部向左移若干位。如：
　　　　　　　　　
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 这种操作时，如果使用左移，将比用乘法快得多。因此在程序中适应的使用左移，可以提高程序的运行效率。

6 ）右移运算符
　　　　　　　　 右移与左移相类似，只是位移的方向不同。如：
　　　　　　　　　　　　　　　　　
a=a>>1


表示将 a 的各位向右移动 1 位。与左移相对应的，左移一位就相当于除以 2 ，右移 N 位，就相当于除以 2N 。
　　　　　　　　　 在右移的过程中，要注意的一个地方就是符号位问题。对于无符号数右移时左边高位移和‘ 0 ’。对于有符号数来说，如果原来符号位为‘ 0 ’，则左边高位为移入‘ 0 ’，而如果符号位为‘ 1 ’，则左边移入‘ 0 ’还是‘ 1 ’就要看实际的编译器了，移入‘ 0 ’的称为“逻辑右移”，移入‘ 1 ’的称为“算术右移”。 Keil 中采用“算术右移”的方式来进行编译。如下：
d=-32; //d 为有符号整型变量，值为-32 ，内存表示为0b 11100000
d=d>>1;// 右移一位 d 为 0b 11110000 即-16 ，Keil 采用" 算术逻辑" 进行编译

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

&=, |=,^=,~=,<<=, >>=
例如： a&=b 相当于 a=a&b,a>>=2 相当于 a>>=2 。
　　 8 ）不同长度的数据进行位运算
　　　　　　　　　　如果参与运算的两个数据的长度不同时，如 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