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

设置一点

使用按位或运算符 (|) 设置位。

number |= 1UL << n;

这将设置 number 的第 n 位。如果您想设置第 1 位，n 应该为零，如果您想设置第 n 位，以此类推直到 n-1。

如果 number 比 unsigned long 宽，则使用 1ULL； 1UL << n 的提升直到在评估 1UL << n 之后才会发生，其中移动超过 long 的宽度是未定义的行为。这同样适用于所有其余示例。

清除一点

使用按位 AND 运算符 (&) 清除位。

number &= ~(1UL << n);

这将清除 number 的第 n 位。您必须使用按位非运算符 (~) 反转位字符串，然后将其与。

切换一下

XOR 运算符 (^) 可用于切换位。

number ^= 1UL << n;

这将切换 number 的第 n 位。

检查了一下

你没有要求这个，但我不妨添加它。

要检查一下，请将数字 n 向右移动，然后按位与它：

bit = (number >> n) & 1U;

这会将 number 的第 n 位的值放入变量 bit。

将第 n 位更改为 x

将第 n 位设置为 1 或 0 可以通过以下在 2 的补码 C++ 实现中实现：

number ^= (-x ^ number) & (1UL << n);

如果 x 是 1 位 n 将被设置，如果 x 是 0 则清零。如果 x 有其他值，你会得到垃圾。 x = !!x 会将其布尔化为 0 或 1。

要使其独立于 2 的补码否定行为（其中 -1 已设置所有位，与 1 的补码或符号/幅度 C++ 实现不同），请使用无符号否定。

number ^= (-(unsigned long)x ^ number) & (1UL << n);

或者

unsigned long newbit = !!x;    // Also booleanize to force 0 or 1
number ^= (-newbit ^ number) & (1UL << n);

使用无符号类型进行可移植位操作通常是一个好主意。

或者

number = (number & ~(1UL << n)) | (x << n);

(number & ~(1UL << n)) 将清除第 n 位，(x << n) 将第 n 位设置为 x。

通常不要复制/粘贴代码也是一个好主意，因此许多人使用预处理器宏（如 the community wiki answer further down）或某种封装。

---

使用标准 C++ 库：std::bitset<N>。

或 Boost 版本：boost::dynamic_bitset。

无需自己动手：

#include <bitset>
#include <iostream>

int main()
{
    std::bitset<5> x;

    x[1] = 1;
    x[2] = 0;
    // Note x[0-4]  valid

    std::cout << x << std::endl;
}

[Alpha:] > ./a.out
00010

与 standard library 编译时大小的位集相比，Boost 版本允许运行时大小的位集。

---

另一种选择是使用位域：

struct bits {
    unsigned int a:1;
    unsigned int b:1;
    unsigned int c:1;
};

struct bits mybits;

定义一个 3 位字段（实际上是三个 1 位字段）。位操作现在变得有点（哈哈）简单：

设置或清除位：

mybits.b = 1;
mybits.c = 0;

稍微切换一下：

mybits.a = !mybits.a;
mybits.b = ~mybits.b;
mybits.c ^= 1;  /* all work */

检查了一下：

if (mybits.c)  //if mybits.c is non zero the next line below will execute

这仅适用于固定大小的位字段。否则，您必须求助于之前文章中描述的位旋转技术。

---

我使用头文件中定义的宏来处理位设置和清除：

/* a=target variable, b=bit number to act upon 0-n */
#define BIT_SET(a,b) ((a) |= (1ULL<<(b)))
#define BIT_CLEAR(a,b) ((a) &= ~(1ULL<<(b)))
#define BIT_FLIP(a,b) ((a) ^= (1ULL<<(b)))
#define BIT_CHECK(a,b) (!!((a) & (1ULL<<(b))))        // '!!' to make sure this returns 0 or 1

#define BITMASK_SET(x, mask) ((x) |= (mask))
#define BITMASK_CLEAR(x, mask) ((x) &= (~(mask)))
#define BITMASK_FLIP(x, mask) ((x) ^= (mask))
#define BITMASK_CHECK_ALL(x, mask) (!(~(x) & (mask)))
#define BITMASK_CHECK_ANY(x, mask) ((x) & (mask))

---

有时值得使用 enum 来命名这些位：

enum ThingFlags = {
  ThingMask  = 0x0000,
  ThingFlag0 = 1 << 0,
  ThingFlag1 = 1 << 1,
  ThingError = 1 << 8,
}

然后稍后使用这些名称。即写

thingstate |= ThingFlag1;
thingstate &= ~ThingFlag0;
if (thing & ThingError) {...}

设置、清除和测试。这样，您就可以从其余代码中隐藏幻数。

除此之外，我支持杰里米的解决方案。

---

来自 snip-c.zip 的 bitops.h：

/*
**  Bit set, clear, and test operations
**
**  public domain snippet by Bob Stout
*/

typedef enum {ERROR = -1, FALSE, TRUE} LOGICAL;

#define BOOL(x) (!(!(x)))

#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))

好吧，我们来分析一下……

在所有这些中您似乎遇到问题的常见表达是“（1L <<（posn））”。所有这一切都是创建一个带有单个位的掩码，它适用于任何整数类型。 “posn”参数指定您想要该位的位置。如果 posn==0，则此表达式的计算结果为：

0000 0000 0000 0000 0000 0000 0000 0001 binary.

如果 posn==8，它将评估为：

0000 0000 0000 0000 0000 0001 0000 0000 binary.

换句话说，它只是在指定位置创建一个 0 和 1 的字段。唯一棘手的部分是在 BitClr() 宏中，我们需要在 1 的字段中设置单个 0 位。这是通过使用波浪号 (~) 运算符表示的相同表达式的 1 补码来实现的。

创建掩码后，它会按照您的建议应用到参数，方法是使用按位和 (&)、或 (|) 和异或 (^) 运算符。由于掩码是 long 类型，因此宏在 char、short、int 或 long 上同样有效。

底线是，这是对一整类问题的通用解决方案。当然，每次需要时都可以使用显式掩码值重写任何这些宏的等效项，甚至是适当的，但为什么要这样做呢？请记住，宏替换发生在预处理器中，因此生成的代码将反映编译器认为这些值是常量这一事实 - 即，每次需要时使用通用宏与“重新发明轮子”一样有效做位操作。

不服气？这是一些测试代码 - 我使用 Watcom C 进行了全面优化，但没有使用 _cdecl，因此生成的反汇编将尽可能干净：

----[ TEST.C ]------------------------------------------ ----------------------

#define BOOL(x) (!(!(x)))

#define BitSet(arg,posn) ((arg) | (1L << (posn)))
#define BitClr(arg,posn) ((arg) & ~(1L << (posn)))
#define BitTst(arg,posn) BOOL((arg) & (1L << (posn)))
#define BitFlp(arg,posn) ((arg) ^ (1L << (posn)))

int bitmanip(int word)
{
      word = BitSet(word, 2);
      word = BitSet(word, 7);
      word = BitClr(word, 3);
      word = BitFlp(word, 9);
      return word;
}

----[ TEST.OUT（拆机）]-------------------------------------------------- ---------

Module: C:\BINK\tst.c
Group: 'DGROUP' CONST,CONST2,_DATA,_BSS

Segment: _TEXT  BYTE   00000008 bytes  
 0000  0c 84             bitmanip_       or      al,84H    ; set bits 2 and 7
 0002  80 f4 02                          xor     ah,02H    ; flip bit 9 of EAX (bit 1 of AH)
 0005  24 f7                             and     al,0f7H
 0007  c3                                ret     

No disassembly errors

----[ 完结 ]-------------------------------------------- ----------------------

---

对于初学者，我想用一个例子来解释一下：

例子：

value is 0x55;
bitnum : 3rd.

& 运算符用于检查位：

0101 0101
&
0000 1000
___________
0000 0000 (mean 0: False). It will work fine if the third bit is 1 (then the answer will be True)

切换或翻转：

0101 0101
^
0000 1000
___________
0101 1101 (Flip the third bit without affecting other bits)

| 运算符：设置位

0101 0101
|
0000 1000
___________
0101 1101 (set the third bit without affecting other bits)

---

由于这被标记为“嵌入式”，我假设您使用的是微控制器。以上所有建议都是有效且有效的（读取-修改-写入、联合、结构等）。

然而，在一次基于示波器的调试过程中，我惊讶地发现，与将值直接写入微控制器的 PORTnSET / PORTnCLEAR 寄存器相比，这些方法在 CPU 周期中具有相当大的开销，这在存在紧密循环/高电平的情况下产生了真正的差异-频率 ISR 的切换引脚。

对于那些不熟悉的人：在我的示例中，微控制器有一个反映输出引脚的通用引脚状态寄存器 PORTn，因此执行 PORTn |= BIT_TO_SET 会导致对该寄存器的读取-修改-写入。但是，PORTnSET / PORTnCLEAR 寄存器采用“1”表示“请将此位设为 1”（SET）或“请将此位设为 0”（CLEAR），而“0”表示“不要管该引脚”。因此，您最终会得到两个端口地址，具体取决于您是设置还是清除该位（并不总是方便），但反应更快，汇编代码更小。

---

这是我最喜欢的位算术宏，它适用于从 unsigned char 到 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, &)) ...

等等

---

位域方法在嵌入式领域还有其他优势。您可以定义一个直接映射到特定硬件寄存器中的位的结构。

struct HwRegister {
    unsigned int errorFlag:1;  // one-bit flag field
    unsigned int Mode:3;       // three-bit mode field
    unsigned int StatusCode:4;  // four-bit status code
};

struct HwRegister CR3342_AReg;

您需要注意位打包顺序 - 我认为它首先是 MSB，但这可能取决于实现。此外，验证您的编译器处理程序如何跨越字节边界。

然后，您可以像以前一样读取、写入、测试各个值。

---

让我们先假设几件事 num = 55 整数来执行按位操作（设置、获取、清除、切换）。 n = 4 0 基于位位置以执行按位运算。

如何获得一点？

得到 num 的第 n 位右移 num，n 次。然后用 1 执行按位与 &。

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 次。然后执行按位 OR |与 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 进行按位与 & 运算。上面三个步骤一起可以写成 num & (~ (1 << n));

https://i.stack.imgur.com/mf8hm.png

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 ^ 运算符。如果两个操作数的对应位不同，则按位异或运算符计算为 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)

推荐阅读 - Bitwise operator exercises

---

检查任意类型变量中任意位置的位：

#define bit_test(x, y)  ( ( ((const char*)&(x))[(y)>>3] & 0x80 >> ((y)&0x07)) >> (7-((y)&0x07) ) )

示例用法：

int main(void)
{
    unsigned char arr[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };

    for (int ix = 0; ix < 64; ++ix)
        printf("bit %d is %d\n", ix, bit_test(arr, ix));

    return 0;
}

注意：这被设计为快速（考虑到它的灵活性）和非分支。在编译 Sun Studio 8 时，它会产生高效的 SPARC 机器代码；我还在 amd64 上使用 MSVC++ 2008 对其进行了测试。可以制作类似的宏来设置和清除位。与这里的许多其他解决方案相比，此解决方案的主要区别在于它适用于几乎任何类型的变量中的任何位置。

---

更一般地说，对于任意大小的位图：

#define BITS 8
#define BIT_SET(  p, n) (p[(n)/BITS] |=  (0x80>>((n)%BITS)))
#define BIT_CLEAR(p, n) (p[(n)/BITS] &= ~(0x80>>((n)%BITS)))
#define BIT_ISSET(p, n) (p[(n)/BITS] &   (0x80>>((n)%BITS)))

---

该程序是将任何数据位从 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);
        }
    }
}

---

如果您正在做很多事情，您可能想要使用掩码，这将使整个事情变得更快。以下函数非常快并且仍然很灵活（它们允许在任何大小的位图中进行位旋转）。

const unsigned char TQuickByteMask[8] =
{
   0x01, 0x02, 0x04, 0x08,
   0x10, 0x20, 0x40, 0x80,
};


/** Set bit in any sized bit mask.
 *
 * @return    none
 *
 * @param     bit    - Bit number.
 * @param     bitmap - Pointer to bitmap.
 */
void TSetBit( short bit, unsigned char *bitmap)
{
    short n, x;

    x = bit / 8;        // Index to byte.
    n = bit % 8;        // Specific bit in byte.

    bitmap[x] |= TQuickByteMask[n];        // Set bit.
}


/** Reset bit in any sized mask.
 *
 * @return  None
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
void TResetBit( short bit, unsigned char *bitmap)
{
    short n, x;

    x = bit / 8;        // Index to byte.
    n = bit % 8;        // Specific bit in byte.

    bitmap[x] &= (~TQuickByteMask[n]);    // Reset bit.
}


/** Toggle bit in any sized bit mask.
 *
 * @return   none
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
void TToggleBit( short bit, unsigned char *bitmap)
{
    short n, x;

    x = bit / 8;        // Index to byte.
    n = bit % 8;        // Specific bit in byte.

    bitmap[x] ^= TQuickByteMask[n];        // Toggle bit.
}


/** Checks specified bit.
 *
 * @return  1 if bit set else 0.
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
short TIsBitSet( short bit, const unsigned char *bitmap)
{
    short n, x;

    x = bit / 8;    // Index to byte.
    n = bit % 8;    // Specific bit in byte.

    // Test bit (logigal AND).
    if (bitmap[x] & TQuickByteMask[n])
        return 1;

    return 0;
}


/** Checks specified bit.
 *
 * @return  1 if bit reset else 0.
 *
 * @param   bit    - Bit number.
 * @param   bitmap - Pointer to bitmap.
 */
short TIsBitReset( short bit, const unsigned char *bitmap)
{
    return TIsBitSet(bit, bitmap) ^ 1;
}


/** Count number of bits set in a bitmap.
 *
 * @return   Number of bits set.
 *
 * @param    bitmap - Pointer to bitmap.
 * @param    size   - Bitmap size (in bits).
 *
 * @note    Not very efficient in terms of execution speed. If you are doing
 *        some computationally intense stuff you may need a more complex
 *        implementation which would be faster (especially for big bitmaps).
 *        See (http://graphics.stanford.edu/~seander/bithacks.html).
 */
int TCountBits( const unsigned char *bitmap, int size)
{
    int i, count = 0;

    for (i=0; i<size; i++)
        if (TIsBitSet(i, bitmap))
            count++;

    return count;
}

请注意，要在 16 位整数中设置位“n”，请执行以下操作：

TSetBit( n, &my_int);

确保位数在您传递的位图范围内由您决定。请注意，对于字节、字、dword、qword 等在内存中正确映射的小端处理器（小端处理器比大端处理器“更好”的主要原因，啊，我感觉一场火焰大战即将来临上...）。

---