C位操作介绍

C++位操作包括两种：传统的C语言方式的位操作和C++中利用bitset容器的位操作
一、传统的C方式位操作：
1.基本操作：
   使用一个unsigned int变量来作为位容器。
2.操作符：
|   按位或操作符：result=exp1|exp2;当exp1和exp2中对应位中至少有一个为1时，result中对应位为1，否则为0。
&  按位与操作符：：result=exp1&exp2;当exp1和exp2中对应位全为1时，result中对应位为1，否则为0。
^  按位异或或操作符：result=exp1^exp2;当exp1和exp2中对应位不相同时，result中对应位为1，否则为0。
~  反转操作符：将位容器中的所有位都反转，1变为0，0变为1。
<< 按位左移操作符：exp<<n，将容器中所有的位向左移n位，空出的位用0填充。
>> 按位右移操作符：exp>>n，将容器中所有的位向右移n位，空出的位用0填充。
|=,&=,^= 分别对应|&^三种操作符的复合操作符。
3.常用操作
这里我们假设有一个result的unsigned int变量用来储存32个学生的成绩（通过和不通过分别用0和1），这样result就有33位（result从右至左，从0开始计算位数，在这个例子中0位被浪费）。
(a) 将第27位设置为及格（设作1）其他位不变：
   result|＝(1<<27) //任意的位值与1作按位或操作其值为1，而与0作按位与操作其值不变
(b) 将第27位设置成不及格（设为0）。
   result&=~(1<<27) //任意的位值与0作按位与操作其值为0，而与1作按位与操作其值不变
(c) 反转第27位的值。
   result^=(1<<27) //任意的位值与1作按位异或操作其值为1，而与0作按位异与操作其值不变

二、C++中的bitset容器
1.头文件：
  #include <bitset>
2.声明一个容器：
(a)声明一个指定位数的空容器（所有位设为0）: bitset<int> bits;
(b)声明一个指定位数并将指定的几个位初始化为相应值的容器： bitset<n> bits(int);
     bitdet<int> bits(string&)
总结：bitset模板类中类型参数传递容器的位数，而构造函数参数通过一个int或一个string&值来从右至左初始化容器中的相应值。
3.bitset的基本用法：
操作                            功能                                   用法
test(pos)                       pos位是否为1                    a.test(4)
any()                            任意位是否为1                   a.any()
none()                          是否没有位为1                   a.none()
count()                         值是1的位的小数              a.count()
size()                           位元素的个数                     a.size()
[pos]                            访问pos位                         a[4]
flip()                             翻转所有位                         a.flip()
flip(pos)                        翻转pos位                         a.flip(4)
set()                            将所有位置1                      a.set()
set(pos)                       将pos位置1                       a.set(4)
reset()                         将所有位置0                      a.reset()
reset(pos)                    将pos位置0                       a.reset(4)
4.bitset与传统C位操作及字符串的转换
   可以通过to_string()成员将容器转输出为一个string字符串，另外还可以用to_long()成员将容器输出到传统的用于C风格的位容器中。如：
  unsigned long bits = bits.to_long();
  sting str(bits.to_string());

 

C语言中常见的置位操作 如何对某一位置0或者置1？
方法一:
写成宏，方便移植
#define setbit(x,y) x|=(1<<y) //将X的第Y位置1
#define clrbit(x,y) x&=!(1<<y) //将X的第Y位清0

方法二:
C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或（|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置

譬如，我们通过将AM186ER型80186处理器的中断屏蔽控制寄存器的
第低6位设置为0（开中断2），最通用的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp &~INT_I2_MASK);
而将该位设置为1的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
outword(INT_MASK, wTemp | INT_I2_MASK);
判断该位是否为1的做法是：
#define INT_I2_MASK 0x0040
wTemp = inword(INT_MASK);
if(wTemp & INT_I2_MASK)
{
… /* 该位为1 */
}
方法三:
int a|=(1<<x) //X就是某位需要置1的数字，如第四位置1为： a|=(1<<4)
int b&=~(1<<x) //把某位置0
x=x|0x0100    //把第三位置1
x=x&0x1011    //把第三位置0
#define BitGet(Number,pos) ((Number) >> (pos)&1)) //用宏得到某数的某位
#define BitGet(Number,pos) ((Number) |= 1<<(pos)) //把某位置1
#define BitGet(Number,pos) ((Number) &= ~(1<<(pos)) //把某位置0
#define BitGet(Number,pos) ((Number) ^= 1<<(pos)) //把Number的POS位取反
典型操作有：
WTCON |=  (1 << 5) //WTCON的第五位清1
WTCON &= ~(1 << 5) //WTCON的第五位清0  

上述方法在嵌入式系统的编程中是非常常见的，我们需要牢固掌握

 

 

C/C++位操作技巧  检测一个无符号数是不为2^n-1(^为幂)：   x&(x+1)   
   
  将最右侧0位改为1位：   x   |   (x+1)   
   
  二进制补码运算公式：   
  -x   =   ~x   +   1   =   ~(x-1)   
  ~x   =   -x-1     
  -(~x)   =   x+1   
  ~(-x)   =   x-1   
  x+y   =   x   -   ~y   -   1   =   (x|y)+(x&y)     
  x-y   =   x   +   ~y   +   1   =   (x|~y)-(~x&y)     
  x^y   =   (x|y)-(x&y)   
  x|y   =   (x&~y)+y   
  x&y   =   (~x|y)-~x   
   
  x==y:         ~(x-y|y-x)   
  x!=y:         x-y|y-x   
  x<   y:         (x-y)^((x^y)&((x-y)^x))   
  x<=y:         (x|~y)&((x^y)|~(y-x))   
  x<   y:         (~x&y)|((~x|y)&(x-y))//无符号x,y比较   
  x<=y:         (~x|y)&((x^y)|~(y-x))//无符号x,y比较   
   
   
  使用位运算的无分支代码：   
   
  计算绝对值   
  int   abs(   int   x   )     
  {   
  int   y   ;   
  y   =   x   >>   31   ;   
  return   (x^y)-y   ;//or:   (x+y)^y   
  }   
   
  符号函数：sign(x)   =   -1,   x<0;   0,   x   ==   0   ;   1,   x   >   0   
  int   sign(int   x)   
  {   
  return   (x>>31)   |   (unsigned(-x))>>31   ;//x=-2^31时失败(^为幂)   
  }   
   
  三值比较：cmp(x,y)   =   -1,   x<y;   0,   x==y;   1,   x   >   y   
  int   cmp(   int   x,   int   y   )   
  {   
  return   (x>y)-(x-y)   ;   
  }   
   
  doz=x-y,   x>=y;   0,   x<y   
  int   doz(int   x,   int   y   )   
  {   
  int   d   ;   
  d   =   x-y   ;   
  return   d   &   ((~(d^((x^y)&(d^x))))>>31)   ;   
  }   
   
  int   max(int   x,   int   y   )     
  {   
  int   m   ;   
  m   =   (x-y)>>31   ;     
  return   y   &   m   |   x   &   ~m   ;   
  }   
   
  不使用第三方交换x,y:   
  1.x   ^=   y   ;   y   ^=   x   ;   x   ^=   y   ;   
  2.x   =   x+y   ;   y   =   x-y   ;   x   =   x-y   ;   
  3.x   =   x-y   ;   y   =   y+x   ;   x   =   y-x   ;   
  4.x   =   y-x   ;   x   =   y-x   ;   x   =   x+y   ;     
   
  双值交换:x   =   a,   x==b;   b,   x==a//常规编码为x   =   x==a   ?   b   :a   ;   
  1.x   =   a+b-x   ;   
  2.x   =   a^b^x   ;   
   
  下舍入到2的k次方的倍数:   
  1.x   &   ((-1)<<k)   
  2.(((unsigned)x)>>k)<<k   
  上舍入：   
  1.   t   =   (1<<k)-1   ;   x   =   (x+t)&~t   ;   
  2.t   =   (-1)<<k   ;   x   =   (x-t-1)&t   ;   
   
  位计数,统计1位的数量：   
  1.   
  int   pop(unsigned   x)   
  {   
  x   =   x-((x>>1)&0x55555555)   ;   
  x   =   (x&0x33333333)   +   ((x>>2)   &   0x33333333   )   ;   
  x   =   (x+(x>>4))   &   0x0f0f0f0f   ;   
  x   =   x   +   (x>>8)   ;   
  x   =   x   +   (x>>16)   ;   
  return   x   &   0x0000003f   ;   
  }   
  2.   
  int   pop(unsigned   x)   {   
  static   char   table[256]   =   {   0,1,1,2,   1,2,2,3,   ....,   6,7,7,8   }   ;   
  return   table[x&0xff]+table[(x>>8)&0xff]+table[(x>>16)&0xff]+table[(x>>24)]   ;   
  }   
   
  奇偶性计算:   
  x   =   x   ^   (   x>>1   )   ;   
  x   =   x   ^   (   x>>2   )   ;   
  x   =   x   ^   (   x>>4   )   ;   
  x   =   x   ^   (   x>>8   )   ;   
  x   =   x   ^   (   x>>16   )   ;   
  结果中位于x最低位，对无符号x,结果的第i位是原数第i位到最左侧位的奇偶性   
   
   
  位反转：   
  unsigned   rev(unsigned   x)   
  {   
  x   =   (x   &   0x55555555)   <<   1   |   (x>>1)   &   0x55555555   ;   
  x   =   (x   &   0x33333333)   <<   2   |   (x>>2)   &   0x33333333   ;   
  x   =   (x   &   0x0f0f0f0f)   <<   4   |   (x>>4)   &   0x0f0f0f0f   ;   
  x   =   (x<<24)   |   ((x&0xff00)<<8)   |   ((x>>8)   &   0xff00)   |   (x>>24)   ;   
  return   x   ;   
  }   
   
  递增位反转后的数：   
  unsigned   inc_r(unsigned   x)   
  {   
  unsigned   m   =   0x80000000   ;   
  x   ^=   m   ;   
  if(   (int)x   >=   0   )     
  do   {   m   >>=   1   ;   x   ^=   m   ;   }   while(   x   <   m   )   ;   
  return   x   ;   
  }   
   
  混选位：   
  abcd   efgh   ijkl   mnop   ABCD   EFGH   IJKL   MNOP->aAbB   cCdD   eEfF   gGhH   iIjJ   kKlL   mMnN   oOpP   
  unsigned   ps(unsigned   x)   
  {   
  unsigned   t   ;   
  t   =   (x   ^   (x>>8))   &   0x0000ff00;   x   =   x   ^   t   ^   (t<<8)   ;   
  t   =   (x   ^   (x>>4))   &   0x00f000f0;   x   =   x   ^   t   ^   (t<<4)   ;   
  t   =   (x   ^   (x>>2))   &   0x0c0c0c0c;   x   =   x   ^   t   ^   (t<<2)   ;   
  t   =   (x   ^   (x>>1))   &   0x22222222;   x   =   x   ^   t   ^   (t<<1)   ;   
  return   x   ;   
  }   
   
  位压缩：   
  选择并右移字x中对应于掩码m的1位的位,如：compress(abcdefgh,01010101)=0000bdfh   
  compress_left(x,m)操作与此类似，但结果位在左边:   bdfh0000.   
  unsigned   compress(unsigned   x,   unsigned   m)   
  {   
  unsigned   mk,   mp,   mv,   t   ;   
  int   i   ;   
   
  x   &=   m   ;   
  mk   =   ~m   <<   1   ;   
  for(   i   =   0   ;   i   <   5   ;   ++i   )   {   
  mp   =   mk   ^   (   mk   <<   1)   ;   
  mp   ^=   (   mp   <<   2   )   ;   
  mp   ^=   (   mp   <<   4   )   ;   
  mp   ^=   (   mp   <<   8   )   ;   
  mp   ^=   (   mp   <<   16   )   ;   
  mv   =   mp   &   m   ;   
  m   =   m   ^   mv   |   (mv   >>   (1<<i)   )   ;   
  t   =   x   &   mv   ;   
  x     =   x   ^   t   |   (   t   >>   (   1<<i)   )   ;   
  mk   =   mk   &   ~mp   ;   
  }   
  return   x   ;   
  }   
   
   
  位置换：   
  用32个5位数表示从最低位开始的位的目标位置，结果是一个32*5的位矩阵，   
  将该矩阵沿次对角线转置后用5个32位字p[5]存放。   
  SAG(x,m)   =   compress_left(x,m)   |   compress(x,~m)   ;   
  准备工作：   
  void   init(   unsigned   *p   )   {   
  p[1]   =   SAG(   p[1],   p[0]   )   ;   
  p[2]   =   SAG(   SAG(   p[2],   p[0]),   p[1]   )   ;   
  p[3]   =   SAG(   SAG(   SAG(   p[3],   p[0]   ),   p[1]),   p[2]   )   ;   
  p[4]   =   SAG(   SAG(   SAG(   SAG(   p[4],   p[0]   ),   p[1])   ,p[2]),   p[3]   )   ;   
  }   
  实际置换：   
  int   rep(   unsigned   x   )   {   
  x   =   SAG(x,p[0]);   
  x   =   SAG(x,p[1]);   
  x   =   SAG(x,p[2]);   
  x   =   SAG(x,p[3]);   
  x   =   SAG(x,p[4]);   
  return   x   ;   
  }   
   
  二进制码到GRAY码的转换:   
  unsigned   B2G(unsigned   B   )   
  {   
  return   B   ^   (B>>1)   ;   
  }   
  GRAY码到二进制码:   
  unsigned   G2B(unsigned   G)   
  {   
  unsigned   B   ;   
  B   =   G   ^   (G>>1)   ;   
  B   =   G   ^   (G>>2)   ;   
  B   =   G   ^   (G>>4)   ;   
  B   =   G   ^   (G>>8)   ;   
  B   =   G   ^   (G>>16)   ;   
  return   B   ;   
  }   
   
  找出最左0字节的位置:   
  int   zbytel(   unsigned   x   )   
  {   
  static   cahr   table[16]   =   {   4,3,2,2,   1,1,1,1,   0,0,0,0,   0,0,0,0   }   ;   
  unsigned   y   ;   
  y   =   (x&0x7f7f7f7f)   +   0x7f7f7f7f   ;   
  y   =   ~(y|x|0x7f7f7f7f)   ;   
  return   table[y*0x00204081   >>   28]   ;//乘法可用移位和加完成   
  }

 

在第一节概述里就说了，C语言是一种中级语言，能对计算机硬件直接操作，这就涉及到位的概念。

一、位的概念
    我们知道，在计算机中，一字节占8位(现在的某些电脑也有占16位的)，这样表示的数的范围为0-255，也即00000000-11111111。位就是里面的0和1。
        char c=100;
    实际上c应该是01100100，正好是64H。其中高位在前，低位在后。                       |             |
                           第7位   第0位

二、位逻辑运算符

        符号         描述
         &           位逻辑与
         |           位逻辑或
         ^           位逻辑异或
         ~           取补

    表中除去最后一个运算符是单目运算符，其他都是双目运算符。这些运算符只能用于整型表达式。位逻辑运算符通常用于对整型变量进行位的设置、清零、取反、以及对某些选定的位进行检测。在程序中一般被程序员用来作为开关标志。较低层次的硬件设备驱动程序，经常需要对输入输出设备进行位操作。

         & 运算的规则是当两个位都为1时，结果为1，否则为0；
         | 运算的规则是当两个位都为0时，结果为0，否则为1；
         ^ 运算的规则是当两个位相同时，结果为0，否则为1；
         ~ 运算的规则是当为1时结果为0，当为0时，结果为1。

    设置位：设置某位为1，而其他位保持不变，可以使用位逻辑或运算。
        char c;
        c=c|0x40;
    这样不论c原先是多少，和01000000或以后，总能使第6位为1，而其他位不变。

    清除位：设置某位为0，而其他位保持不变。可以使用位逻辑与运算。
        c=c&0xBF;
    这样c和10111111与以后，总能使第6位为0，其他位保持不变。
    那如果想让某位为1，其他位都为0怎么办呢？

三、位移运算符
         符号             描述
          <<              左移
          >>              右移

    位移运算符作用于其左侧的变量，其右侧的表达式的值就是移动的位数，运算结果就是移动后的变量结果。
        b=a<<2;
    就是a的值左移两位并赋值为b。a本身的值并没有改变。
               
    向左移位就是在低位沙锅补0，向右移位就是在高位上补0。右移时可以保持结果的符号位，也就是右移时，如果最高位为1，是符号位，则补1而不是补0。
    程序员常常对右移运算符来实现整数除法运算，对左移运算符来实现整数乘法运算。其中用来实现乘法和除法的因子必须是2的幂次。

    举例：输入一个整数，判断这个数中有几个二进制位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语言中位操作用法

在对单处机进行编程的过程中，对位的操作是经常遇到的。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

 

[C语言的移位操作]
一，
I=257 = 1 0000 0001  (二进制)
I=257/8 = 32.125 = 32   (I为int类型)

I=257>  >  3
=1 0000 0001>  >    3 = 0...010 0000=2^5=32
右移3位将将最后一个001移除了，1/8=0.125   所以这等价是没问题的

二
J=456=0...01 1100 1000
J=456%32=8;      (J为int类型)
J=456-(456>  >  4  <  <4);   
456>  >  4=0...01 1100 1000>  >  4
            =0...01 1100
然后再左移四位，则低四位补0：   0...01 1100 0000
上面两步实际上是将低四位变为了0，也就是由原来的1000变为现在的0000
所以现在数比移位操作前少了1000，也就是8
所以J=456-(456>  >  4  <  <4)=8

这里的求余运算我们还可以这样：
456=0...01 1100 1000=0x1c8
那么求456%32，就只要知道低5位是多大就OK了
所以456%32=0x1c8 & 0x01f,这样从第6位开始就全部变为0，余下的就是所求。

三

J=456=0...01 1100 1000
从上面的分析就知道
456>  >  3  <  <3比456而言就是低3位 000 变为现在的 000，
嘿嘿，没变，所以 k  = 456 - (456>  >  3  <  <3)=0

456>  >  4  <  <4比456而言就是低4位 1000 变为现在的 0000，
小了8，所以 l  = 456 - (456>  >  4  <  <4)=8

456>  >  5  <  <5比456而言就是低5位 01000 变为现在的 00000，
小了8，所以 m  = 456 - (456>  >  5  <  <5)=8

456>  >  6  <  <6比456而言就是低6位 001000 变为现在的 000000，
小了8，所以 n  = 456 - (456>  >  6  <  <6)=8

456>  >  7  <  <7比456而言就是低7位 1001000 变为现在的 0000000，
小了2^6+2^3=64+8=72，所以 o = 456 - (456>  >  7  <  <7)=72

 

c++位运算（收藏用）[url=] 楼主[/url]snowingbf（snowingbf）2004-10-19 00:03:07 在 C/C++ / C++ 语言 提问
前言   
  看到有些人对位运算还存在问题，于是决定写这篇文章作个简要说明。   
   
  什么是位(bit)？   
   
  很简单，位(bit)就是单个的0或1，位是我们在计算机上所作一切的基础。计算机上的所有数据都是用位来存储的。一个字节(BYTE)由八个位组成，一个字(WORD)是二个字节或十六位，一个双字(DWORD)是二个字(WORDS)或三十二位。如下所示：   
   
      0   1   0   0   0   1   1   1   1   0   0   0   0   1   1   1   0   1   1   1   0   1   0   0   0   1   1   1   1   0   0   0   
  |   |                             |                               |                               |                             |   |   
  |   +-   bit   31             |                               |                               |               bit   0   -+   |   
  |                                 |                               |                               |                                 |   
  +--   BYTE   3   ----   -+----   BYTE   2   ---+----   BYTE   1   ---+---   BYTE   0   -----+   
  |                                                                 |                                                                 |   
  +------------   WORD   1   ------------+-----------   WORD   0   -------------+   
  |                                                                                                                                   |   
  +-----------------------------   DWORD   -----------------------------+   
   
  使用位运算的好处是可以将BYTE,   WORD   或   DWORD   作为小数组或结构使用。通过位运算可以检查位的值或赋值，也可以对整组的位进行运算。   
   
  16进制数及其与位的关系   
  用0或1表示的数值就是二进制数，很难理解。因此用到16进制数。   
   
  16进制数用4个位表示0   -   15的值，4个位组成一个16进制数。也把4位成为半字节(nibble)。一个BYTE有二个nibble，因此可以用二个16进制数表示一个BYTE。如下所示：   
   
  NIBBLE       HEX   VALUE   
  ======       =========   
    0000                 0   
    0001                 1   
    0010                 2   
    0011                 3   
    0100                 4   
    0101                 5   
    0110                 6   
    0111                 7   
    1000                 8   
    1001                 9   
    1010                 A   
    1011                 B   
    1100                 C   
    1101                 D   
    1110                 E   
    1111                 F   
   
  如果用一个字节存放字母"r"(ASCII码114)，结果是：   
  0111   0010         二进制   
      7         2           16进制   
   
  可以表达为：'0x72'   
   
  有6种位运算：   
        &       与运算   
        |       或运算   
        ^       异或运算   
        ~       非运算(求补)   
      >>       右移运算   
      <<       左移运算   
   
  与运算(&)   
  双目运算。二个位都置位(等于1)时，结果等于1，其它的结果都等于0。   
        1       &       1       ==       1   
        1       &       0       ==       0   
        0       &       1       ==       0   
        0       &       0       ==       0   
   
  与运算的一个用途是检查指定位是否置位(等于1)。例如一个BYTE里有标识位，要检查第4位是否置位，代码如下：   
   
  BYTE   b   =   50;   
  if   (   b   &   0x10   )   
          cout   <<   "Bit   four   is   set"   <<   endl;   
  else   
          cout   <<   "Bit   four   is   clear"   <<   endl;   
   
  上述代码可表示为：   
   
          00110010     -   b   
      &   00010000     -   &   0x10   
    ----------------------------   
          00010000     -   result   
   
  可以看到第4位是置位了。   
   
  或运算(   |   )   
  双目运算。二个位只要有一个位置位，结果就等于1。二个位都为0时，结果为0。   
        1       |       1       ==       1   
        1       |       0       ==       1   
        0       |       1       ==       1   
        0       |       0       ==       0   
   
  与运算也可以用来检查置位。例如要检查某个值的第3位是否置位：   
   
  BYTE   b   =   50;   
  BYTE   c   =   b   |   0x04;   
  cout   <<   "c   =   "   <<   c   <<   endl;   
   
  可表达为：   
   
          00110010     -   b   
      |   00000100     -   |   0x04   
      ----------   
          00110110     -   result   
   
  异或运算(^)   
  双目运算。二个位不相等时，结果为1，否则为0。   
   
        1       ^       1       ==       0   
        1       ^       0       ==       1   
        0       ^       1       ==       1   
        0       ^       0       ==       0   
   
  异或运算可用于位值翻转。例如将第3位与第4位的值翻转：   
   
  BYTE   b   =   50;   
  cout   <<   "b   =   "   <<   b   <<   endl;   
  b   =   b   ^   0x18;   
  cout   <<   "b   =   "   <<   b   <<   endl;   
  b   =   b   ^   0x18;   
  cout   <<   "b   =   "   <<   b   <<   endl;   
   
  可表达为：   
   
          00110010     -   b   
      ^   00011000     -   ^0x18   
      ----------   
          00101010     -   result   
   
          00101010     -   b   
      ^   00011000     -   ^0x18   
      ----------   
          00110010     -   result   
   
  非运算(~)   
  单目运算。位值取反，置0为1，或置1为0。非运算的用途是将指定位清0，其余位置1。非运算与数值大小无关。例如将第1位和第2位清0，其余位置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。如将第4位清0：   
   
  BYTE   b   =   50;   
  cout   <<   "b   =   "   <<   b   <<   endl;   
  BYTE   c   =   b   &   ~0x10;   
  cout   <<   "c   =   "   <<   c   <<   endl;   
   
  可表达为：   
   
          00110010     -   b   
      &   11101111     -   ~0x10   
      ----------   
          00100010     -   result   
   
  移位运算(>>   与   <<)   
  将位值向一个方向移动指定的位数。右移   >>   算子从高位向低位移动，左移   <<   算子从低位向高位移动。往往用位移来对齐位的排列(如MAKEWPARAM,   HIWORD,   LOWORD   宏的功能)。   
   
  BYTE   b   =   12;   
  cout   <<   "b   =   "   <<   b   <<   endl;   
  BYTE   c   =   b   <<   2;   
  cout   <<   "c   =   "   <<   c   <<   endl;   
  c   =   b   >>   2;   
  cout   <<   "c   =   "   <<   c   <<   endl;   
   
  可表达为：   
          00001100     -   b   
          00110000     -   b   <<   2   
          00000011     -   b   >>   2   
   
  译注：以上示例都对，但举例用法未必恰当。请阅文末链接的文章，解释得较为清楚。   
   
  位域(Bit   Field)   
  位操作中的一件有意义的事是位域。利用位域可以用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位。这样整个日期数据只需占用23位，即3个字节。忽略第24位。如果用整数来表达各个域，整个结构要占用12个字节。   
   
  |   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。1个BYTE有8个位，编译器将分配1个BYTE的内存。如果结构内的数据超过8位，编译器就再分配1个BYTE，直到满足数据要求。如果用WORD或DWORD作结构的数据类型，编译器就分配一个完整的32位内存给结构。   
   
  其次看一下域声明。变量(day,   month,   year)名跟随一个冒号，冒号后是变量占用的位数。位域之间用逗号分隔，用分号结束。   
   
  使用了位域结构，就可以方便地象处理普通结构数据那样处理成员数据。尽管我们无法得到位域的地址，却可以使用结构地址。例如：   
  date.day   =   12;   
  dateptr   =   &date;   
  dateptr->year   =   1852;