C/C++位操作

C/C++位操作详解

最新推荐文章于 2024-10-25 11:05:56 发布

转载最新推荐文章于 2024-10-25 11:05:56 发布 · 399 阅读

文章标签：

C/C++位操作

一、传统的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的位的小数 count()
size() 位元素的个数 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());

---------------------------------------------------------------------------------------------------

什么是位(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;