从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.

换句话说，它只需在指定的位置唯一棘手的部分是我们需要设置的BitClr（）宏1字段中的单个0位。这是通过使用1与颚化符（~）运算符表示的表达式相同的补码。

一旦创建了掩码，它将按照您的建议应用于参数，使用按位和（&）、或（|）和xor（^）运算符。自从面具类型为long，宏将在char、short、int、，或长的。

底线是，这是一个通用的解决方案问题。当然，重写相当于每次使用显式掩码值的任何宏需要一个，但为什么要这样做？请记住，宏替换发生在因此生成的代码将反映以下事实：被编译器认为是常量，即使用起来同样有效每当你需要做的时候，通用宏都会“重新发明轮子”比特操作。

不服气？下面是一些测试代码-我使用了Watcom C，并进行了全面优化并且不使用_cdecl，因此生成的反汇编将与可能：

----[测试.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;
}

----[测试输出（拆卸）]-----------------------------------------------

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

----[完成]-----------------------------------------------------------------

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

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，但这可能取决于实现。此外，验证编译器处理程序字段如何跨越字节边界。

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

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

要解决试图形成掩码时的常见编码陷阱，请执行以下操作：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;

---

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

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

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

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

如果你在做很多无聊的事情，你可能会想使用口罩，这会让整个事情变得更快。以下函数速度非常快，而且仍然灵活（它们允许在任何大小的位图中进行位旋转）。

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等的小端处理器，它们在内存中正确地相互映射（小端处理器比大端处理器“更好”的主要原因，啊，我感觉到一场火焰大战即将到来…）。

设置一位

使用按位OR运算符（|）设置位。

number |= 1UL << n;

这将设置数字的第n位。如果要将第1位设置为n-1，那么n应该为零，如果要设置第n位。

如果数字大于无符号长，则使用1ULL；1UL<<n的提升直到评估1UL<<n之后才发生，其中移动超过长的宽度是未定义的行为。这同样适用于所有其他示例。

清除一点

使用位AND运算符（&）清除位。

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

这将清除数字的第n位。必须使用按位NOT运算符（~）反转位字符串，然后对其进行AND运算。

稍微扭动一下

XOR运算符（^）可用于切换位。

number ^= 1UL << n;

这将切换数字的第n位。

检查一点

你没有要求这样做，但我不妨补充一下。

要检查一位，请向右移动数字n，然后按位“与”：

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

这将把数字第n位的值放入变量位。

将第n位更改为x

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

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

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

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

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

or

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

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

or

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

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

一般来说，不复制/粘贴代码也是一个好主意，因为很多人使用预处理器宏（如社区wiki答案）或某种封装。