C/C++位操作的原理与实际应用

gaosmile

【导读】：本文详细讲解C/C++位操作的原理与实际应用,非常值得学习。

以下是正文

---

位操作（Bit Operation）

位操作与逻辑操作

位操作不同于逻辑操作，逻辑操作是一种整体的操作，而位操作是针对内部数据位补码的操作。逻辑操作的世界里只有真假（零与非零），而位操作的世界里按位论真假（1和0）。运算也不相同。

数据的二进制形式表示8位二进制数据的补码

eg:打印一个32位数据的二进制

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. 
    
22. int main()
    
23. {
    
24.     int a = 0xffffffff;//-1内存中的形式
    
25.     dis32bin(a);
    
26. 
    
27.     return 0;
    
28. }

复制代码

按位&（与）

同1为1，否则为0。

非1跟1按位与保持不变，1跟1按位与为1，跟0按位与清零。

性质：用1&，在某些位保持不变的情况下，某些清零。

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. 
    
22. int main()
    
23. {
    
24.     //int a = 0xffffffff;//-1内存中的形式
    
25.     int a = 3;
    
26.     int b = 11;
    
27.     dis32bin(a);
    
28.     dis32bin(b);
    
29.     printf("\n------------------------------\n");
    
30.     dis32bin(a&b);
    
31.     int c = a&b;
    
32.     printf("c = %d\n",c);
    
33. 
    
34.     return 0;
    
35. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0000-0011
   
4. 0000-0000 0000-0000 0000-0000 0000-1011
   
5. 
   
6. ---------------------------------------
   
7. 0000-0000 0000-0000 0000-0000 0000-0011
   
8. c = 3
   
9. */

复制代码

按位或|(或)

只有两个都为0时才为0，其余为1.

跟1按位或置1，非0跟0或保持不变，0跟0或为0.

性质：用0|,在某些位保持不变的情况下，某些置1.

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. int main() {
    
22.     int a = 3;
    
23.     int b = 9;
    
24.     dis32bin(a);
    
25.     dis32bin(b);
    
26.     printf("\n-----------------------------------------\n");
    
27.     dis32bin(a|b);
    
28.     int c = a|b;
    
29.     printf("a|b = %d\n",c);
    
30. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0000-0011
   
4. 0000-0000 0000-0000 0000-0000 0000-1001
   
5. 
   
6. -----------------------------------------
   
7. 0000-0000 0000-0000 0000-0000 0000-1011
   
8. a|b = 11
   
9. */

复制代码

• 位取反（~）
  

个各位反转，1->0,0->1

按位取反，用于间接的构造某些数据。

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. int main()
    
22. {
    
23.     int a = 0x55;
    
24.     dis32bin(a);
    
25.     dis32bin(~a);//a本身并未发生变化
    
26. 
    
27.     dis32bin(0);
    
28.     dis32bin(~0);
    
29. 
    
30.     return 0;
    
31. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0101-0101
   
4. 1111-1111 1111-1111 1111-1111 1010-1010
   
5. 0000-0000 0000-0000 0000-0000 0000-0000
   
6. 1111-1111 1111-1111 1111-1111 1111-1111
   
7. */

复制代码

位异或(^)(相异者或)

相异者1，相同者0

跟1按位异或取反，跟0按位异或保持不变。

性质：用1^,某些位保持不变的情况下，某些取反

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. int main()
    
22. {
    
23.     int a = 0x55;
    
24.     int b = 0xff;
    
25.     dis32bin(a);
    
26.     dis32bin(b);
    
27.    
    
28.     dis32bin(a^b);
    
29.     printf("\n=============================\n");
    
30.     int c = 0;
    
31.     dis32bin(a);
    
32.     dis32bin(c);
    
33.     dis32bin(a^c);
    
34.     printf("\n=============================\n");
    
35.     int d = 0x0f;
    
36.     dis32bin(a);
    
37.     dis32bin(d);
    
38.     dis32bin(a^d);
    
39. 
    
40.     return 0;
    
41. 
    
42. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0101-0101
   
4. 0000-0000 0000-0000 0000-0000 1111-1111
   
5. 0000-0000 0000-0000 0000-0000 1010-1010
   
6. 
   
7. =============================
   
8. 0000-0000 0000-0000 0000-0000 0101-0101
   
9. 0000-0000 0000-0000 0000-0000 0000-0000
   
10. 0000-0000 0000-0000 0000-0000 0101-0101
    
11. 
    
12. =============================
    
13. 0000-0000 0000-0000 0000-0000 0101-0101
    
14. 0000-0000 0000-0000 0000-0000 0000-1111
    
15. 0000-0000 0000-0000 0000-0000 0101-1010
    
16. */

复制代码

左移(<<)和右移(>>)

规则：使操作数的各位左移，低位补0，高位溢出。

移位大于32位时,对32求模运算.

左移不溢出的情况下：数字左移相当于乘以2^几次幂

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. int main()
    
22. {
    
23.     int a = 0x01;
    
24.     dis32bin(a);
    
25.     dis32bin(a<<1);
    
26.     dis32bin( (a<<31)+1 << 1);
    
27. /*
    
28. 0000-0000 0000-0000 0000-0000 0000-0001
    
29. 0000-0000 0000-0000 0000-0000 0000-0010
    
30. 0000-0000 0000-0000 0000-0000 0000-0010
    
31. */
    
32. 
    
33.     dis32bin(a<<32);
    
34.     dis32bin(a<<33);
    
35.     dis32bin(a<<34);
    
36.     printf("a<<33 = %d\n",a<<32);
    
37.     printf("a<<33 = %d\n",a<<33);
    
38.     printf("a<<34 = %d\n",a<<34);
    
39. /*
    
40. 0000-0000 0000-0000 0000-0000 0000-0001
    
41. 0000-0000 0000-0000 0000-0000 0000-0010
    
42. 0000-0000 0000-0000 0000-0000 0000-0100
    
43. a<<33 = 1
    
44. a<<33 = 2
    
45. a<<34 = 4
    
46. */   
    
47.     return 0;
    
48. }

复制代码

右移(>>)

规则：使操作数的各位右移，移除低位舍弃。

高位：

1.对无符号数和有符号中的整数补0；

2.有符号数中的负数，取决于所使用的系统；补0的称为逻辑右移，补1的称为算数右移
在不溢出的情况下，数字左移相当于除以2^几次幂

同样大于32时对32求模运算。

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. int main()
    
22. {
    
23. //第一种情况：无符号数和有符号整数，高位补0，低位舍弃
    
24.     unsigned int a = 0x55;
    
25.     dis32bin(a);
    
26.     dis32bin(a>>4);
    
27.     int b = 1;
    
28.     dis32bin(b);
    
29.     dis32bin(b>>1);
    
30. printf("\n===========================\n");
    
31. //第二种情况：有符号中的负数：高位补0逻辑右移，高位补1，算数右移。
    
32.     int c = 0x800000f0;
    
33.     dis32bin(c);
    
34.     dis32bin(c>>1);
    
35.     dis32bin(c>>2);
    
36.     dis32bin(c>>3);
    
37. 
    
38.     return 0;
    
39. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0101-0101
   
4. 0000-0000 0000-0000 0000-0000 0000-0101
   
5. 0000-0000 0000-0000 0000-0000 0000-0001
   
6. 0000-0000 0000-0000 0000-0000 0000-0000
   
7. 
   
8. =======================================
   
9. 1000-0000 0000-0000 0000-0000 1111-0000
   
10. 1100-0000 0000-0000 0000-0000 0111-1000
    
11. 1110-0000 0000-0000 0000-0000 0011-1100
    
12. 1111-0000 0000-0000 0000-0000 0001-1110
    
13. */

复制代码

应用

掩码

用一个状态模拟8盏灯的状态操作。

0x55 = 0101 0101，1开 0关

需求在此基础上打开从右至左第四盏灯

1. 
   
2. void dis32bin(int data)
   
3. {
   
4.     int i = 32;
   
5.     while(i--)
   
6.     {
   
7.         if(data & (1<<i))
   
8.             printf("1");
   
9.         else
   
10.             printf("0");
    
11.         if(i%4 == 0)
    
12.         {
    
13.             if(i%8 == 0)
    
14.                 printf(" ");
    
15.             else
    
16.                 printf("-");
    
17.         }
    
18.     }
    
19.     putchar(10);
    
20. }
    
21. 
    
22. int main()
    
23. {
    
24.     //0101 0101，
    
25.     int ch = 0x55;
    
26.     int mask = 1<<3;//从本身位置开始移动
    
27.     dis32bin(ch);
    
28.     ch = ch | mask;
    
29.     dis32bin(ch);
    
30.     /*
    
31. 0000-0000 0000-0000 0000-0000 0101-0101
    
32. 0000-0000 0000-0000 0000-0000 0101-1101   
    
33.     */
    
34.     return 0;
    
35. }

复制代码

需求2:将从左至右第五位关闭

1. 
   
2. int main()
   
3. {
   
4. // 0101 0101
   
5. // 1110 1111  求&运算即可
   
6. //~0001 0000
   
7.     int ch = 0x55;
   
8.     int mask = ~(1<<4);
   
9.     dis32bin(ch);
   
10.     dis32bin(mask);
    
11.     ch = ch & mask;
    
12.     dis32bin(ch);
    
13. 
    
14.     return 0;
    
15. }

复制代码

1. 
   
2. /*
   
3. 0000-0000 0000-0000 0000-0000 0101-0101
   
4. 1111-1111 1111-1111 1111-1111 1110-1111
   
5. 0000-0000 0000-0000 0000-0000 0100-0101
   
6. 
   
7. */

复制代码

需求3：从左至右将第三位，第五位关闭

分析：
原有状态：0101 0101

假设状态：1110 1011

假设取反：0001 0100

只需完成假设取反的状态和原有状态取反即可

1左移4位：0001 0000

1左移2位：0000 0100

<=> (1<<4) | (1<<2)

1. 
   
2. int main()
   
3. {
   
4.     int ch = 0x55;
   
5.     int mask = ~ ( (1<<4) | (1<<3) );
   
6.     //ch = ch & mask;
   
7.     ch &= mask;
   
8.     dis32bin(ch);
   
9. 
   
10.     return 0;
    
11. 
    
12.     //0000-0000 0000-0000 0000-0000 0100-0001
    
13. }

复制代码

需求4：从左至右第三位到第六位反转

分析：

原有状态：0101 0101 ^异或运算

假设状态：0011 1100

目标状态：0110 1001

假设状态：0010 0000

假设状态：0001 0000

假设状态：0000 1000

假设状态：0000 0100

最终状态：0011 1100

1. 
   
2. int main()
   
3. {
   
4.     int ch = 0x55;
   
5.     int mask = (1<<5)|(1<<4)|(1<<3)|(1<<2);
   
6.     dis32bin(ch);
   
7.     ch ^= mask;
   
8.     dis32bin(mask);
   
9.     dis32bin(ch);
   
10.     return 0;
    
11. /*
    
12. 0000-0000 0000-0000 0000-0000 0101-0101
    
13. 0000-0000 0000-0000 0000-0000 0011-1100
    
14. 0000-0000 0000-0000 0000-0000 0110-1001
    
15. */
    
16. }

复制代码

查看某一位的状态

需求从左至右第五位的状态

分析：

原有状态：0101 0101

假设状态：0001 0000 求 & =1

1. 
   
2. int main()
   
3. {
   
4.     int ch = 0x55;
   
5.     int mask = 1<<4;
   
6.     if(ch&mask)
   
7.         printf("此位为1\n");
   
8.     else
   
9.         printf("此位为0\n");
   
10. 
    
11.     return 0;
    
12.     //此位为1
    
13. }

复制代码

位操作的总结

1.你要操作的那几位

2.找到合适的掩码

3.找到合适的位运算

test:

从键盘输入一个整数，输出3-6位构成的数（从低位0号开始编号）

1. 
   
2. //先进行掩码的设置操作，之后在位移
   
3. int main()
   
4. {   
   
5.     //0101 0101
   
6.     int a = 0x55;
   
7.     int mask = a<<3|a<<4|a<<5|a<<6;
   
8.     a &= mask;
   
9.     a >>= 3;
   
10.     printf("a = %d\n",a);
    
11. }
    
12. 
    
13. //先位移，在进行掩码的设置操作
    
14. int main()
    
15. {
    
16.     int a = 0x55;
    
17.     a >>= 3;
    
18.     int mask = 0x0f;
    
19.     a &= mask;
    
20.     printf("a = %d\n",a);
    
21. 
    
22.     return 0;
    
23. }

复制代码

优先级

1. 
   
2. () > 成员运算 > (!) 算术 > 关系 > 逻辑 > 赋值>
   
3. () > 成员运算 > (~!) 算术 > 关系 > (>> <<) 位逻辑(& | ^) 逻辑 > 赋值>

复制代码

循环移位

1. 
   
2. #include<stdio.h>
   
3. void dis32bin(int data)
   
4. {
   
5.     int i = 32;
   
6.     while(i--)
   
7.     {
   
8.         if(data & (1<<i))
   
9.             printf("1");
   
10.         else
    
11.             printf("0");
    
12.         if(i%4 == 0)
    
13.         {
    
14.             if(i%8 == 0)
    
15.                 printf(" ");
    
16.             else
    
17.                 printf("-");
    
18.         }
    
19.     }
    
20.     putchar(10);
    
21. }
    
22. 
    
23. //用无符号的类型，避免了右移补1的问题
    
24. void circleMove(unsigned int *pa,int n)
    
25. {
    
26.     n %= 32;
    
27.     if(n>0)//左移
    
28.         *pa = (*pa<<n) | (*pa>>(sizeof(*pa)*8-n));
    
29.     else//右移逻辑
    
30.         *pa = (*pa>>(-n)) | (*pa<<(sizeof(*pa)*8-(-n)));
    
31. }
    
32. int main()
    
33. {
    
34.     int a = 0x80000001;//1000***0001
    
35. 
    
36.     circleMove(&a,1);
    
37.     dis32bin(a);
    
38. 
    
39.     return 0;
    
40. }

复制代码

无参交换

1. 
   
2. int mySwap(int *pa,int *pb)
   
3. {
   
4. //引入第三者
   
5.     int t = *pa;
   
6.     *pa = *pb;
   
7.     *pb = t;
   
8. }
   
9. //以知两者的和，可以求任何其中之一,有益处的弊端
   
10. int mySwap1(int *pa1,int *pb1)
    
11. {
    
12.     *pa1 = *pa1 + *pb1;
    
13.     *pb1 = *pa1 - *pb1;
    
14.     *pa1 = *pa1 - *pb1;
    
15. }
    
16. //x,y,x^y,三者之间两两求异或运算即可得到第三者。和加法的思路一样。
    
17. int mySwap2(int *pa2,int *pb2)
    
18. {
    
19.     *pa2 = *pa2 ^ *pb2;
    
20.     *pb2 = *pa2 ^ *pb2;
    
21.     *pa2 = *pa2 ^ *pb2;
    
22.     /*
    
23.     *pa2 ^= *pb2;
    
24.     *pb2 ^= *pa2;
    
25.     *pa2 ^= *pb2;
    
26.     */
    
27. }
    
28. int main() {
    
29.     int a = 3;
    
30.     int b = 5;
    
31.     mySwap(&a,&b);
    
32. 
    
33.     return 0;
    
34. }

复制代码

异或加密(文本与二进制)

1. 
   
2. void encode(char *buf,char ch)
   
3. {
   
4.     int len = strlen(buf);
   
5.     for(int i = 0;i < len;i++)
   
6.     {
   
7.         buf[i] ^= ch;
   
8.     }
   
9. }
   
10. void decode(char *buf,char ch)
    
11. {
    
12.     int len = strlen(buf);
    
13.     for(int i = 0;i < len;i++)
    
14.     {
    
15.         buf[i] ^= ch;
    
16.     }
    
17. }
    
18. 
    
19. int main()
    
20. {
    
21.     char buf[] = "I love C++";
    
22.     printf("buf = %s\n",buf);
    
23.     char ch = 'a';//这种只要传入相同的字符就会出错。
    
24.     encode(buf,ch);
    
25.     printf("buf = %s\n",buf);
    
26.     decode(buf,ch);
    
27.     printf("buf = %s\n",buf);
    
28. 
    
29.     return 0;
    
30. }
    
31. 
    
32. 
    
33. int a;
    
34. a ^= a;
    
35. printf("a = %d\n";a); //自身异或清零。

复制代码

改进：

1. 
   
2. void encode(char *buf,char ch)
   
3. {
   
4.     int len = strlen(buf);
   
5.     for(int i = 0;i < len;i++)
   
6.     {
   
7.         if(buf[i] == ch)
   
8.             continue;
   
9.         buf[i] ^= ch;
   
10.     }
    
11. }
    
12. void decode(char *buf,char ch)
    
13. {
    
14.     int len = strlen(buf);
    
15.     for(int i = 0;i < len;i++)
    
16.     {
    
17.         if(buf[i] == ch)
    
18.             continue;
    
19.         buf[i] ^= ch;
    
20.     }
    
21. }
    
22. 
    
23. int main()
    
24. {
    
25.     char buf[] = "I love C++";
    
26.     printf("buf = %s\n",buf);
    
27.     char ch = 'a';//这种只要传入相同的字符就会出错。
    
28.     encode(buf,ch);
    
29.     printf("buf = %s\n",buf);
    
30.     decode(buf,ch);
    
31.     printf("buf = %s\n",buf);
    
32. 
    
33.     return 0;
    
34. }

复制代码

升级：

1. 
   
2. #include<stdio.h>
   
3. void encode(char *buf,char *px)
   
4. {
   
5.     int len = strlen(buf);
   
6.     int n = strlen(px);
   
7.     int j = 0;
   
8.     for(int i = 0;i < len;i++)
   
9.     {
   
10.         if(buf[i] == px[j])
    
11.             j++;
    
12.         else
    
13.         {
    
14.             buf[i] ^= px[j++];
    
15.             if(j == n)
    
16.                 j = 0;
    
17.         }
    
18.     }
    
19. 
    
20. }
    
21. void decode(char *buf,char *px)
    
22. {
    
23.     int len = strlen(buf);
    
24.     int n = strlen(px);
    
25.     int j = 0;
    
26.     for(int i = 0;i < len;i++)
    
27.     {
    
28.         if(buf[i] == px[j])
    
29.             j++;
    
30.         else
    
31.         {
    
32.             buf[i] ^= px[j++];
    
33.             if(j == n)
    
34.                 j = 0;
    
35.         }
    
36.     }
    
37. 
    
38. }
    
39. 
    
40. int main()
    
41. {
    
42.     char buf[] = "i love you";
    
43.     char xx[] = "19920415";
    
44.     encode(buf,xx);
    
45.     printf("buf = %s\n",buf);
    
46. 
    
47.     char buf2[1024];
    
48.     scanf("%s",buf2);
    
49.     decode(buf,buf2);
    
50.     printf("buf = %s\n",buf);
    
51. 
    
52.     return 0;
    
53. }

复制代码

二进制加密没有上述是否相等问题。

循环移位加密

二进制加密：

1. 
   
2. void encode(char *buf,int n);
   
3. void decode(char *buf,int n)
   
4. int main()
   
5. {
   
6.     FILE *pfr = fopen("01.png","rb+");
   
7.     if(pfr == NULL)
   
8.         exit(-1);
   
9. 
   
10.     FILE *pfw = fopen("02.png","wb+");
    
11.     if(pfw == NULL)
    
12.         exit(-1);
    
13. /* 解密
    
14.     FILE *pfr = fopen("02.png","rb+");
    
15.     if(pfr == NULL)
    
16.         exit(-1);
    
17. 
    
18.     FILE *pfw = fopen("03.png","wb+");
    
19.     if(pfw == NULL)
    
20.         exit(-1);
    
21. 
    
22. */
    
23. 
    
24. 
    
25.     char buf[1024];
    
26.     int n;
    
27.     while((n = fread(buf,1,1024,pfr)) > 0)
    
28.     {
    
29.         encode(buf,n);
    
30.         //decode(buf,n);解密
    
31.         fwrite(buf,1,n,pfw);
    
32.     }
    
33.     fclose(pfr);
    
34.     fclose(pfw);
    
35. 
    
36.     return 0;
    
37. }
    
38. void encode(char *buf,int n)
    
39. {
    
40.     for(int i = 0;i < n;i++)
    
41.     {
    
42.         unsigned char ch = buf[i];
    
43.         buf[i] = ch<<1 | ch>>7;
    
44.     }
    
45. }
    
46. 
    
47. void decode(char *buf,int n)
    
48. {
    
49.     for(int i = 0;i < n;i++)
    
50.     {
    
51.         unsigned char ch = buf[i];
    
52.         buf[i] = ch>>1 | ch<<7;
    
53.     }
    
54. }

复制代码