最近在学习的时候，遇到了位操作，发觉自己对于位操作特别的不敏感，于是找了一篇博文进行学习，然后一下为学习笔记，因为博文写的比较少，所以文章结构将仿照原博文。
一、位操作基础
基本的位操作符有与、或、异或、取反、左移、右移，运算规则如下：
注：
- 除了取反运算符是单目运算符，其他都是双目运算符；
- 位操作只能用于整型数据，对于float和double类型进行位操作会被编译器报错；
- 对于移位操作，编译器会有两类方式，分别是算术移位操作和逻辑移位操作。这两种方式，在左移操作时，都只要低位补0即可，而在右移操作时，算术右移会在高位补符号位，逻辑右移会在高位补0。如以下代码：
int a,b;
a = 15, b = -15;
printf("a=%d, b=%d",a >> 2,b >> 2);在dev-cpp中，进行的是算术右移操作，其结果为3和-4 。
因为-15 = 1111 0001b(只取一个字节，忽略前面3个字节，下同)，右移2位，最高位由符号位填充，得到1111 1100b=-4，而15=0000 1111，最高位由符号位填充，得到0000 0011b=3。
4. 位操作符运算优先级较低，所以尽量用括号来确保运算顺序，否则可能会出现莫名其妙的结果。
5. 位操作符的符合操作符有：&=、|=、>>=、<<=、^=。
二、位操作小技巧
下面对位操作的一些常见应用作个总结，有判断奇偶、交换两数、变换符号及求绝对值。这些小技巧应用易记，应当熟练掌握。
- 判断奇偶
数的奇偶由数的最末尾一位来决定，0为偶，1为奇。因此可以用if((a & 1) == 0)代替if((a %2) == 0)来判断a是不是偶数。
下列程序输出1~100所有偶数：
int i;
for(i=1; i<101; ++i){
if(!(i & 1))
printf("%d ",i);
} - 交换两数
这个方法，在我的另外一篇随笔中已经有记录，是利用了数与自己异或等于0，以及异或满足交换律，从而实现了不需要额外变量实现两个数的交换，具体方法实现如下：
void Swap(int &a, int &b){
if (a != b){
a ^= b;
b ^= a;
a ^= b;
}
}以这样理解：
第一步：a = a ^ b;
第二步：b = a ^ b;即b = b ^ (a ^ b);而一个数与本身异或得0且异或满足交换律，于是，就变成了b = b ^ b ^ a;也就是b = a;此时b便赋予了a的值。
第三步：a = a ^ b;由于第二步中已经使得b = a;此时的运算变成了a = a ^ b ^ a;即a = b;如此，便实现了a与b的值进行交换。
举个实例，int a = 4, b = 12;
a = 0100b
b = 1100b
a ^= b a = 0100 ^ 1100 = 1000;
b ^= a b = 1100 ^ 1000 = 0100;即b = 4;
a ^= b a = 1000 ^ 0100 = 1100;即a = 12;
- 交换符号
交换符号即正数变负数，负数变正数。
在计算机存储中，数是以补码形式存储的，而负数的补码便是其对应正数的反码加一，又补码的补码为原码。故不管正负数，只要取其补码，变能得到其相反数。
比如对于12和-12，可以通过以下的方法使12变成-12：
12 = 0000 1100 (取反)–> 1111 0011 (加一)–> 1111 0100b = -12.
同样的方法使12变成-12：
-12 = 1111 0100 (取反)–> 0000 1011 (加一)–> 0000 1100b = 12.
代码如下：
#include "stdio.h"
int SignReversal(int a){
return ~a + 1;
}
int main(){
int a = 12;
printf("a=%d",SignReversal(a));
return 0;
} - 求绝对值
求绝对值主要需要判断数的正负，如果是负数，则利用取反加一的方法，来得到负数的相反数。而要判断数的正负，要取其符号位，可以通过移位来实现，int i = a >> 31;当a为负时，i = 1;当i = 1的时候，返回~a + 1即可。
函数代码如下：
int my_abs(int a){
int i = a >> 31;
return i == 0 ? a : (~a + 1);
}而对此函数，可以进行再分析。因为对于任何数，与0异或都会保持不变，而与-1即0xFFFFFFFF异或相当于取反。而上诉方法，只需要在i=1的时候，返回取反加1，所以，其实可以直接返回a与i进行异或，然后再加上一。完整代码如下：
int my_abs(int a){
int i = a >> 31;
return ((a ^ i) + 1);
}三． 位操作与空间压缩
筛素数法在这里不就详细介绍了，本文着重对筛素数法所使用的素数表进行优化来减小其空间占用。要压缩素数表的空间占用，可以使用位操作。下面是用筛素数法计算100以内的素数示例代码。
#include <stdio.h>
#include <memory.h>
#define MAXN 100
int flag[MAXN];
int primes[MAXN / 3 + 1], pi;
//对每个素数，它的倍数必定不是素数。
//有很多重复如flag[10]会在访问flag[2]和flag[5]时各访问一次
void GetPrime_1()
{
int i, j;
pi = 0;
memset(flag, false, sizeof(flag));
for (i = 2; i < MAXN; i++)
if (!flag[i])
{
primes[pi++] = i;
for (j = i; j < MAXN; j += i)
flag[j] = true;
}
}
void PrintfArray()
{
int i;
for (i = 0; i < pi; i++)
printf("%d ", primes[i]);
putchar('\n');
}
int main()
{
printf("用筛素数法求100以内的素数\n");
GetPrime_1();
PrintfArray();
return 0;
}首先是在一个数指定位上置1，这只需要将1左移后与这个整数相或来实现，代码如下：
//在一个数指定位上置1
int j = 0;
j |= 1 << 10;
printf("%d\n", j); 同样，可以1向左移位后与原数相与来判断指定位上是0还是1（也可以将原数右移若干位再与1相与）。
#include "stdio.h"
int main(){
int j = 1 << 10;
if((j & (1 << 10)) != 0)
printf("指定位上是1");
else
printf("指定位上是0");
return 0;
}扩展到数组上，我们可以采用这种方法，因为数组在内存上也是连续分配的一段空间，完全可以“认为”是一个很长的整数。先写一份测试代码，看看如何在数组中使用位操作：
#include "stdio.h"
int main(){
int b[5] = {0};
int i;
for(i=0; i<40; i += 3)
b[i/32] |= (1 << (i % 32));
for(i=0; i<40; i++){
if((b[i/32] >> (i%32)) & 1)
putchar('1');
else
putch('0');
}
return 0;
}测试结果为：
可以看见，每3个位就被置成了1，证明上面我们对于数组的操作是正确的，因此可以将上面的筛素数方法改成用位操作压缩后的筛素数方法：
#include "stdio.h"
#include "memory.h"
#define MAXN 100
int flag[MAXN / 32 + 1];
int primes[MAXN / 3 + 1], pi;
void GetPrime_1(){
int i,j;
pi = 0;
memset(flag, 0, sizeof(flag));
for(i=2; i<100; ++i){
if(!((flag[i/32] >> (i%32)) & 1)){
primes[pi++] = i;
for(j=i; j<MAXN; j+=i)
flag[j/32] |= 1 << (j%32);
}
}
}
void PrintArray(){
int i;
for(i=0; i<pi; ++i)
printf("%d ",primes[i]);
}
int main(){
GetPrime_1();
PrintArray();
return 0;
}运行结果与上相同，而这种方法，可以充分利用空间。
四． 位操作的趣味应用
- 高低位交换
给出一个16位的无符号整数。称这个二进制数的前8位为“高位”，后8位为“低位”。现在写一程序将它的高低位交换。
例如，数34520用二进制表示为：
10000110 11011000
将它的高低位进行交换，我们得到了一个新的二进制数：
11011000 10000110
它即是十进制的55430。
这个问题用位操作解决起来非常方便，设x=34520=10000110 11011000(二进制)，由于x为无符号数，右移时会执行逻辑右移即高位补0，因此x右移8位将得到00000000 10000110。而x左移8位将得到11011000 00000000。可以发现只要将x>>8与x<<8这两个数相或就可以得到11011000 10000110。用代码实现非常简洁：
#include "stdio.h"
void PrintfBinary(unsigned short a){
int i;
for(i=sizeof(a)*8-1; i>=0; --i){
if(((a>>i) & 1))
putch('1');
else
putch('0');
}
putch('\n');
}
int main(){
unsigned short a = 34520;
PrintfBinary(a);
a = (a >> 8) | (a << 8);//相应位 置1
PrintfBinary(a);
return 0;
}运行结果如下：
- 二进制逆序
我们知道如何对字符串求逆序，现在要求计算二进制的逆序，如数34520用二进制表示为：
10000110 11011000
将它逆序，我们得到了一个新的二进制数：
00011011 01100001
它即是十进制的7009。
回顾下字符串的逆序，可以从字符串的首尾开始，依次交换两端的数据。在二进制逆序我们也可以用这种方法，但运用位操作的高低位交换来处理二进制逆序将会得到更简洁的方法。类似于归并排序的分组处理，可以通过下面4步得到16位数据的二进制逆序：
第一步：每2位为一组，组内高低位交换
10 00 01 10 11 01 10 00
–>
01 00 10 01 11 10 01 00
第二步：每4位为一组，组内高低位交换
0100 1001 1110 0100
–>
0001 0110 1011 0001
第三步：每8位为一组，组内高低位交换
00010110 10110001
–>
01100001 00011011
第四步：每16位为一组，组内高低位交换
01100001 00011011
–>
00011011 01100001
对第一步，可以依次取出每2位作一组，再组内高低位交换，这样有点麻烦，下面介绍一种非常有技巧的方法。先分别取10000110 11011000的奇数位和偶数位，空位以下划线表示。
原 数 10000110 11011000
奇数位 1_0_0_1_ 1_0_1_0_
偶数位 _0_0_1_0 _1_1_0_0
将下划线用0填充，可得
原 数 10000110 11011000
奇数位 10000010 10001000
偶数位 00000100 01010000
再将奇数位右移一位，偶数位左移一位，此时将这两个数据相或即可以达到奇偶位上数据交换的效果了。
原 数 10000110 11011000
奇数位右移 01000001 01000100
偶数位左移 00001000 10100000
相或得到 01001001 11100100
可以看出，结果完全达到了奇偶位的数据交换，再来考虑代码的实现——
取x的奇数位并将偶数位用0填充用代码实现就是x & 0xAAAA
取x的偶数位并将奇数位用0填充用代码实现就是x & 0x5555
因此，第一步就用代码实现就是：
x = ((x & 0xAAAA) >> 1) | ((x & 0x5555) << 1);
类似可以得到后三步的代码。完整程序如下：
#include "stdio.h"
void PrintfBinary(unsigned short a){
int i;
for(i=sizeof(a)*8-1; i>=0; --i){
if(((a>>i) & 1))
putch('1');
else
putch('0');
}
putch('\n');
}
int main(){
unsigned short a = 34520;
printf("交换前： ");
PrintfBinary(a);
printf("交换后： ");
a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1);
a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2);
a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4);
a = ((a & 0xFF00) >> 8) | ((a & 0x00FF) << 8);
PrintfBinary(a);
return 0;
}运行结果：
- 二进制中1的个数
统计二进制中1的个数可以直接移位再判断，当然像《编程之美》书中用循环移位计数或先打一个表再计算都可以。本文详细讲解一种高效的方法。以34520为例，可以通过下面四步来计算其二进制中1的个数二进制中1的个数。
第一步：每2位为一组，组内高低位相加
10 00 01 10 11 01 10 00
–>
01 00 01 01 10 01 01 00
第二步：每4位为一组，组内高低位相加
0100 0101 1001 0100
–>
0001 0010 0011 0001
第三步：每8位为一组，组内高低位相加
00010010 00110001
–>
00000011 00000100
第四步：每16位为一组，组内高低位相加
00000011 00000100
–>
00000000 00000111
这样最后得到的00000000 00000111即7即34520二进制中1的个数。类似上文中对二进制逆序的做法不难实现第一步的代码：
x = ((x & 0xAAAA) >> 1) + (x & 0x5555);
好的，有了第一步，后面几步就请读者完成下吧，先动动笔再看下面的完整代码
#include "stdio.h"
void PrintfBinary(unsigned short a){
int i;
for(i=sizeof(a)*8-1; i>=0; --i){
if(((a>>i) & 1))
putch('1');
else
putch('0');
}
putch('\n');
}
int main(){
unsigned short a = 34520;
printf("原数 %6d的二进制为: ", a);
PrintfBinary(a);
a = ((a & 0xAAAA) >> 1) + (a & 0x5555);
a = ((a & 0xCCCC) >> 2) + (a & 0x3333);
a = ((a & 0xF0F0) >> 4) + (a & 0x0F0F);
a = ((a & 0xFF00) >> 8) + (a & 0x00FF);
printf("计算结果%6d的二进制为: ", a);
PrintfBinary(a);
return 0;
}
- 缺失的数字
很多成对出现数字保存在磁盘文件中，注意成对的数字不一定是相邻的，如2, 3, 4, 3, 4, 2……，由于意外有一个数字消失了，如何尽快的找到是哪个数字消失了？
由于有一个数字消失了，那必定有一个数只出现一次而且其它数字都出现了偶数次。用搜索来做就没必要了，利用异或运算的两个特性
1.自己与自己异或结果为0，
2.异或满足交换律。
因此我们将这些数字全异或一遍，结果就一定是那个仅出现一个的那个数。 示例代码如下：
#include <stdio.h>
#define MAXN 15
int main()
{
int i;
int a[MAXN] = {1, 347, 6, 9, 13, 65, 889, 712, 889, 347, 1, 9, 65, 13, 712};
int lostNum = 0;
for(i=0; i<MAXN; ++i)
lostNum ^= a[i];
printf("lostNum is %d",lostNum);
return 0;
}
7168
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
