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

设置位

使用按位 OR 运算符 （） 将 的第 1 位设置为 。|nnumber1

// Can be whatever unsigned integer type you want, but
// it's important to use the same type everywhere to avoid
// performance issues caused by mixing integer types.
typedef unsigned long Uint;

// In C++, this can be template.
// In C11, you can make it generic with _Generic, or with macros prior to C11.
inline Uint bit_set(Uint number, Uint n) {
    return number | ((Uint)1 << n);
}

请注意，移动超过 .这同样适用于所有剩余的示例。Uint

稍微清除一下

使用按位 AND 运算符 （） 将 的第 1 位设置为 。&nnumber0

inline Uint bit_clear(Uint number, Uint n) {
    return number & ~((Uint)1 << n);
}

您必须使用按位 NOT 运算符 （） 反转位字符串，然后使用 AND it。~

切换一点

使用按位异或运算符 （） 切换 的第 1 位。^nnumber

inline Uint bit_toggle(Uint number, Uint n) {
    return number ^ ((Uint)1 << n);
}

检查一下

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

要检查一点，请向右移动，然后按位移动：numbern

// bool requires #include <stdbool.h> prior to C23
inline bool bit_check(Uint number, Uint n) {
    return (number >> n) & (Uint)1;
}

将第 n位更改为 x

还有其他方法的 codegen 较差，但最好的方法是清除 中的位，然后将位设置为值，类似于 。bit_clearbit_set

inline Uint bit_set_to(Uint number, Uint n, bool x) {
    return (number & ~((Uint)1 << n)) | ((Uint)x << n);
}

---

所有解决方案都经过测试，可通过 GCC 和 clang 提供最佳的代码生成。请参见 https://godbolt.org/z/Wfzh8xsjW。

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

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

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

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

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

除此之外，我赞同佩奇·鲁滕（Paige Ruten）的解决方案。

另一种选择是使用位字段：

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

struct bits mybits;

定义一个 3 位字段（实际上，它是三个 1 位felds）。位操作现在变得更简单了（哈哈）：

要设置或清除位：

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

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

来自 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 的 与波浪号 （~） 运算符表示的相同表达式的补码。

创建掩码后，它会像您建议的那样应用于参数， 通过使用按位和 （&）、或 （|） 和 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;
}

----[ TEST.OUT (disassembled) ]-----------------------------------------------

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

----[ finis ]-----------------------------------------------------------------

如果你正在做很多一些摆弄，你可能想使用蒙版，这将使整个事情更快。以下函数速度非常快，并且仍然很灵活（它们允许在任何大小的位图中进行位摆弄）。

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);

由您来确保位号在您传递的位图范围内。请注意，对于小端处理器，字节、单词、dwords、qwords 等在内存中正确地相互映射（小端处理器比大端处理器“更好”的主要原因，啊，我感觉一场激烈的战争即将到来......

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

或者 Boost 版本：boost：:d ynamic_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;
}

---

./a.out

输出：

00010

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

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

/* 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))

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

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

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

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

#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 对其进行了测试。可以制作类似的宏来设置和清除位。与这里的许多其他解决方案相比，此解决方案的主要区别在于，它适用于几乎任何类型的变量中的任何位置。

使用这个：

int ToggleNthBit ( unsigned char n, int num )
{
    if(num & (1 << n))
        num &= ~(1 << n);
    else
        num |= (1 << n);

    return num;
}

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

#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)))

这是我最喜欢的位算术宏，它适用于任何类型的无符号整数数组，从最多到（这是应该有效使用的最大类型）：unsigned charsize_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, &)) ...

等。

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

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

例：

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)

|operator：设置位

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

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

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

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

Visual C 2010 和许多其他编译器都直接支持内置的布尔运算。位有两个可能的值，就像布尔值一样，因此我们可以改用布尔值，即使在此表示中它们占用的空间比内存中的单个位多。这有效，甚至操作员也能正常工作。sizeof()

bool IsGph[256], IsNotGph[256];

// Initialize boolean array to detect printable characters
for(i=0; i<sizeof(IsGph); i++) {
    IsGph[i] = isgraph((unsigned char)i);
}

因此，对于您的问题，或使设置和清除布尔值变得容易。IsGph[i] =1IsGph[i] =0

要查找不可打印的字符：

// Initialize boolean array to detect UN-printable characters,
// then call function to toggle required bits true, while initializing a 2nd
// boolean array as the complement of the 1st.
for(i=0; i<sizeof(IsGph); i++) {
    if(IsGph[i]) {
        IsNotGph[i] = 0;
    } 
    else {
        IsNotGph[i] = 1;
    }
}

请注意，此代码没有任何“特殊”之处。它有点像一个整数——从技术上讲，确实如此。一个 1 位整数，可以保存两个值，并且只能保存两个值。

我曾经使用这种方法来查找重复的贷款记录，其中loan_number是 ISAM 密钥，使用六位数的贷款编号作为位数组的索引。 它的速度非常快，八个月后，证明我们从中获取数据的大型机系统实际上出现了故障。位数组的简单性使其对正确性的信心非常高，例如，与搜索方法相比。

扩展答案：bitset

#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;
}

尝试在 C 语言中使用以下函数之一来更改 n 位：

char bitfield;

// Start at 0th position

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & (~( (1 << n) ^ (value << n) ));
}

或

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & ((value << n) | ((~0) ^ (1 << n)));
}

或

void chang_n_bit(int n, int value)
{
    if(value)
        bitfield |= 1 << n;
    else
        bitfield &= ~0 ^ (1 << n);
}

char get_n_bit(int n)
{
    return (bitfield & (1 << n)) ? 1 : 0;
}

以下是我使用的一些宏：

SET_FLAG(Status, Flag)            ((Status) |= (Flag))
CLEAR_FLAG(Status, Flag)          ((Status) &= ~(Flag))
INVALID_FLAGS(ulFlags, ulAllowed) ((ulFlags) & ~(ulAllowed))
TEST_FLAGS(t,ulMask, ulBit)       (((t)&(ulMask)) == (ulBit))
IS_FLAG_SET(t,ulMask)             TEST_FLAGS(t,ulMask,ulMask)
IS_FLAG_CLEAR(t,ulMask)           TEST_FLAGS(t,ulMask,0)

如果您想在 Linux 内核中使用 C 编程执行所有这些操作，那么我建议使用 Linux 内核的标准 API。

请参阅第 2 章。C 库基本函数

set_bit  Atomically set a bit in memory
clear_bit  Clears a bit in memory
change_bit  Toggle a bit in memory
test_and_set_bit  Set a bit and return its old value
test_and_clear_bit  Clear a bit and return its old value
test_and_change_bit  Change a bit and return its old value
test_bit  Determine whether a bit is set

注意：在这里，整个操作只需一个步骤即可完成。因此，即使在 SMP 计算机上，这些都保证是原子的，并且对于保持处理器之间的一致性很有用。

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

解决尝试形成掩码时常见的编码陷阱：
1 并不总是足够宽

当类型比 更宽时会发生什么问题？
对于导致未定义行为 （UB） 的转变来说可能太大了。即使不是太大，也可能没有翻转足够多的最有效位。number1x1 << xx~

// 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(uintmax_t)1

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

或投射 - 这会导致编码/审查/维护问题，以保持投射的正确性和最新性。

number |= (type_of_number)1 << x;

或者通过强制执行至少与 的类型一样宽的数学运算来温和地提升 。1number

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

---

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

支持更改多个位的模板化版本（放在头文件中）（顺便说一句，适用于 AVR 微控制器）：

namespace bit {
  template <typename T1, typename T2>
  constexpr inline T1 bitmask(T2 bit) 
  {return (T1)1 << bit;}
  template <typename T1, typename T3, typename ...T2>
  constexpr inline T1 bitmask(T3 bit, T2 ...bits) 
  {return ((T1)1 << bit) | bitmask<T1>(bits...);}

  /** Set these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void set (T1 &variable, T2 ...bits) 
  {variable |= bitmask<T1>(bits...);}
  /** Set only these bits (others will be cleared) */
  template <typename T1, typename ...T2>
  constexpr inline void setOnly (T1 &variable, T2 ...bits) 
  {variable = bitmask<T1>(bits...);}
  /** Clear these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void clear (T1 &variable, T2 ...bits) 
  {variable &= ~bitmask<T1>(bits...);}
  /** Flip these bits (others retain their state) */
  template <typename T1, typename ...T2>
  constexpr inline void flip (T1 &variable, T2 ...bits) 
  {variable ^= bitmask<T1>(bits...);}
  /** Check if any of these bits are set */
  template <typename T1, typename ...T2>
  constexpr inline bool isAnySet(const T1 &variable, T2 ...bits) 
  {return variable & bitmask<T1>(bits...);}
  /** Check if all these bits are set */
  template <typename T1, typename ...T2>
  constexpr inline bool isSet (const T1 &variable, T2 ...bits) 
  {return ((variable & bitmask<T1>(bits...)) == bitmask<T1>(bits...));}
  /** Check if all these bits are not set */
  template <typename T1, typename ...T2>
  constexpr inline bool isNotSet (const T1 &variable, T2 ...bits) 
  {return ((variable & bitmask<T1>(bits...)) != bitmask<T1>(bits...));}
}

使用示例：

#include <iostream>
#include <bitset> // for console output of binary values

// and include the code above of course

using namespace std;

int main() {
  uint8_t v = 0b1111'1100;
  bit::set(v, 0);
  cout << bitset<8>(v) << endl;

  bit::clear(v, 0,1);
  cout << bitset<8>(v) << endl;

  bit::flip(v, 0,1);
  cout << bitset<8>(v) << endl;

  bit::clear(v, 0,1,2,3,4,5,6,7);
  cout << bitset<8>(v) << endl;

  bit::flip(v, 0,7);
  cout << bitset<8>(v) << endl;
}

顺便说一句：事实证明，如果不向编译器发送优化器参数（例如：-O3），则不会使用 constexpr 和 inline。请随意尝试 https://godbolt.org/ 的代码并查看 ASM 输出。

int set_nth_bit(int num, int n){    
    return (num | 1 << n);
}

int clear_nth_bit(int num, int n){    
    return (num & ~( 1 << n));
}

int toggle_nth_bit(int num, int n){    
    return num ^ (1 << n);
}

int check_nth_bit(int num, int n){    
    return num & (1 << n);
}

让我们先假设几件事：

num = 55：用于执行按位运算（set、get、clear 和 toggle）的整数。

n = 4：从 0 开始的位位置，用于执行按位运算。

我们怎样才能得到一点？

要获得数字，右移位，时间。然后用 1 按位执行 AND。nthnumn&

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 次。然后使用 执行按位 OR 运算。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. 左移 1，次，即 .n1 << n
2. 对上述结果进行按位补码。因此，第 n 位变为未设置，其余位变为已设置，即 .~ (1 << n)
3. 最后，对上述结果和 执行按位 AND 运算。以上三个步骤一起可以写成&numnum & (~ (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)

该程序基于 Jeremy 的解决方案。如果有人想快速玩。

public class BitwiseOperations {

    public static void main(String args[]) {

        setABit(0, 4);    // Set the 4th bit, 0000 -> 1000 [8]
        clearABit(16, 5); // Clear the 5th bit, 10000 -> 00000 [0]
        toggleABit(8, 4); // Toggle the 4th bit, 1000 -> 0000 [0]
        checkABit(8, 4);  // Check the 4th bit 1000 -> true
    }

    public static void setABit(int input, int n) {
        input = input | (1 << n-1);
        System.out.println(input);
    }


    public static void clearABit(int input, int n) {
        input = input & ~(1 << n-1);
        System.out.println(input);
    }

    public static void toggleABit(int input, int n) {
        input = input ^ (1 << n-1);
        System.out.println(input);
    }

    public static void checkABit(int input, int n) {
        boolean isSet = ((input >> n-1) & 1) == 1;
        System.out.println(isSet);
    }
}

输出：

8
0
0
true

在不使用 -1 的情况下将第 n 位设置为 x（位值）

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

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

解释：将第 n 位设置为 1（其中表示按位 OR），然后我们将第 n 位设置为 0，最后将第 n 位设置为 0，设置为（位值）。((number | (1 << n)|(...) ^ (1 << n)(...) | x << n)x

这在 Go 中也有效。

下面是 C 语言中用于执行基本按位运算的例程：

#define INT_BIT (unsigned int) (sizeof(unsigned int) * 8U) //number of bits in unsigned int

int main(void)
{
    
    unsigned int k = 5; //k is the bit position; here it is the 5th bit from the LSb (0th bit)
    
    unsigned int regA = 0x00007C7C; //we perform bitwise operations on regA
    
    regA |= (1U << k);    //Set kth bit
    
    regA &= ~(1U << k);   //Clear kth bit
    
    regA ^= (1U << k);    //Toggle kth bit
    
    regA = (regA << k) | regA >> (INT_BIT - k); //Rotate left by k bits
    
    regA = (regA >> k) | regA << (INT_BIT - k); //Rotate right by k bits

    return 0;   
}