如何设置、清除和切换单个位？

要解决试图形成掩码时的常见编码陷阱，请执行以下操作：1并不总是足够宽

当数字的类型大于1时会出现什么问题？x对于移位1<<x可能太大，导致未定义的行为（UB）。即使x不太大，~也可能无法翻转足够多的最高有效位。

// assume 32 bit int/unsigned
unsigned long long number = foo();

unsigned x = 40; 
number |= (1 << x);  // UB
number ^= (1 << x);  // UB
number &= ~(1 << x); // UB

x = 10;
number &= ~(1 << x); // Wrong mask, not wide enough

要确保1足够宽：

代码可以使用1ull或pedatically（uintmax_t）1并让编译器进行优化。

number |= (1ull << x);
number |= ((uintmax_t)1 << x);

或铸造-这使得编码/审查/维护问题保持铸造正确和最新。

number |= (type_of_number)1 << x;

或者通过强制一个至少与数字类型一样宽的数学运算来温和地推广1。

number |= (number*0 + 1) << x;

与大多数位操作一样，最好使用无符号类型而不是有符号类型

这是我最喜欢的位算术宏，它适用于从无符号字符到size_t的任何类型的无符号整数数组（这是应该有效使用的最大类型）：

#define BITOP(a,b,op) \
 ((a)[(size_t)(b)/(8*sizeof *(a))] op ((size_t)1<<((size_t)(b)%(8*sizeof *(a)))))

要设置位：

BITOP(array, bit, |=);

要清除一点：

BITOP(array, bit, &=~);

要切换一位，请执行以下操作：

BITOP(array, bit, ^=);

要测试一点：

if (BITOP(array, bit, &)) ...

etc.

此程序用于将任何数据位从0更改为1或从1更改为0：

{
    unsigned int data = 0x000000F0;
    int bitpos = 4;
    int bitvalue = 1;
    unsigned int bit = data;
    bit = (bit>>bitpos)&0x00000001;
    int invbitvalue = 0x00000001&(~bitvalue);
    printf("%x\n",bit);

    if (bitvalue == 0)
    {
        if (bit == 0)
            printf("%x\n", data);
        else
        {
             data = (data^(invbitvalue<<bitpos));
             printf("%x\n", data);
        }
    }
    else
    {
        if (bit == 1)
            printf("elseif %x\n", data);
        else
        {
            data = (data|(bitvalue<<bitpos));
            printf("else %x\n", data);
        }
    }
}

展开位集答案：

#include <iostream>
#include <bitset>
#include <string>

using namespace std;
int main() {
  bitset<8> byte(std::string("10010011");

  // Set Bit
  byte.set(3); // 10010111

  // Clear Bit
  byte.reset(2); // 10010101

  // Toggle Bit
  byte.flip(7); // 00010101

  cout << byte << endl;

  return 0;
}

将第n位设置为x（位值），不使用-1

有时，当您不确定-1或类似的结果时，您可能希望在不使用-1的情况下设置第n位：

number = (((number | (1 << n)) ^ (1 << n))) | (x << n);

解释：（（number |（1<<n）将第n位设置为1（其中|表示逐位OR），然后使用（…）^（1<<n）将将第n个位设置为0，最后通过（…）|x<<n，将第n比特设置为0（位值）x。

这也适用于戈朗。

先假设几件事num=55整数以执行逐位操作（set、get、clear、toggle）。n＝4 0位位置，以执行逐位操作。

如何获得一点？

要获得num的第n位，请右移num，n次。然后用1执行逐位AND&。

bit = (num >> n) & 1;

它是如何工作的？

       0011 0111 (55 in decimal)
    >>         4 (right shift 4 times)
-----------------
       0000 0011
     & 0000 0001 (1 in decimal)
-----------------
    => 0000 0001 (final result)

如何设置一点？

设置数字的特定位。左移1 n次。然后用num。

num |= (1 << n);    // Equivalent to; num = (1 << n) | num;

它是如何工作的？

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     | 0011 0111 (55 in decimal)
-----------------
    => 0001 0000 (final result)

如何清除一点？

左移1，n次，即1<<n。对上述结果执行按位补码。因此，第n位变为未置位，其余位变为置位，即~（1<<n）。最后，对上述结果和num执行逐位AND&运算。上述三个步骤一起可以写成num&（~（1<<n））；

num &= (~(1 << n));    // Equivalent to; num = num & (~(1 << n));

它是如何工作的？

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
     ~ 0001 0000
-----------------
       1110 1111
     & 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)

如何切换一点？

要切换位，我们使用逐位XOR^运算符。如果两个操作数的对应位不同，则逐位XOR运算符的计算结果为1，否则计算结果为0。

这意味着要切换一个位，我们需要对要切换的位和1执行XOR运算。

num ^= (1 << n);    // Equivalent to; num = num ^ (1 << n);

它是如何工作的？

如果要切换的位为0，则0 ^1=>1。如果要切换的位为1，则1^1=>0。

       0000 0001 (1 in decimal)
    <<         4 (left shift 4 times)
-----------------
       0001 0000
     ^ 0011 0111 (55 in decimal)
-----------------
    => 0010 0111 (final result)

推荐阅读-按位操作员练习