c++ - 位运算 - 位掩码




你如何设置,清除和切换一个位? (18)

你如何设置,清除和切换一个位?

为了解决在尝试形成掩模时常见的编码缺陷:
1并不总是足够宽

什么问题number1什么更广泛?
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或迂腐(uintmax_t)1,让编译器进行优化。

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

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

number |= (type_of_number)1 << x;

或者1通过强制进行至少与类型一样宽的数学运算来轻轻地促进number

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

与大多数位操作,最好与工作无符号的类型,而不是签署

如何在C / C ++中设置,清除和切换?


设置一下

使用按位OR运算符( | )设置一个位。

number |= 1UL << n;

这将设置第n numbern应该为零,如果要设置第1位,依此类推,最多为n-1 ,如果要设置第n位。

如果number宽于unsigned long ,则使用1ULL ; 促进1UL << n直到评估1UL << n之后才会发生,其中未定义的行为偏移超过长度的宽度。 这同样适用于所有其他示例。

清理一下

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

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

这将清除第nnumber 。 必须使用按位NOT运算符( ~ )反转位串,然后运行AND。

切换了一下

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

number ^= 1UL << n;

这将切换数字的第n位。

检查一下

你没有要求这个,但我不妨补充一下。

要检查一下,将数字n向右移动,然后按位移动它:

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

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

将第n位更改为x

将第n位设置为10可以通过以下2的补码C ++实现来实现:

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

如果x1 ,则设置位n ,如果x0 ,则清除位n 。 如果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);

使用无符号类型进行便携式位操作通常是个好主意。

一般来说,通常不要复制/粘贴代码也是一个好主意,因此很多人使用预处理器宏(如社区维基回答更进一步 )或某种封装。


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

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


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] = 1,或IsGph [i] = 0使设置和清除bool变得容易。

要找到不可打印的字符......

//  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位整数,可以容纳2个值,仅包含2个值。

我曾经使用这种方法来查找重复的贷款记录,其中loan_number是ISAM密钥,使用6位数的贷款编号作为位数组的索引。野蛮快速,8个月后证明我们从中获取数据的主机系统实际上是故障。位阵列的简单性使得它们的正确性非常高 - 例如,与搜索方法相比。


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

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,但这可能与实现有关。 另外,验证编译器处理程序如何跨越字节边界。

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


使用按位运算符: & |

要设置000b最后一位:

foo = foo | 001b

检查foo最后一位:

if ( foo & 001b ) ....

要清除foo最后一位:

foo = foo & 110b

为清楚起见,我使用了XXXb 。 您可能正在使用HEX表示,具体取决于您打包位的数据结构。


变量使用

int value, pos;

value - 数据
位置 - 我们有兴趣设置,清除或切换
的位的位置设置一个位

value = value | 1 << pos;

清楚一点

value = value & ~(1 << pos); 

切换一下

value = value ^ 1 << pos;

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

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

这仅适用于固定大小的位字段。 否则你必须采用之前帖子中描述的比特技巧。


如果你做了很多事情,你可能想要使用面具,这将使整个事情变得更快。 以下函数非常快并且仍然灵活(它们允许在任何大小的位图中进行位错)。

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

由您来确保位数在您传递的位图范围内。 请注意,对于小端字处理器,字节,字,双字,qword等在内存中正确映射(小端处理器比大端处理器“更好”的主要原因啊,我感觉到了一场火焰战争即将到来上...)。


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

例:

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)

扩展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;
}

更常见的是,对于任意大小的位图:

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

用这个:

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

    return num;
}

由于这被标记为“嵌入式”,我假设你正在使用微控制器。 所有上述建议都是有效的和工作(读 - 修改 - 写,工会,结构等)。

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

对于那些不熟悉的人:在我的例子中,micro有一个通用的引脚状态寄存器PORTn,它反映了输出引脚,所以做PORTn | = BIT_TO_SET会导致对该寄存器的读 - 修改 - 写。 但是,PORTnSET / PORTnCLEAR寄存器的“1”表示“请将该位置1”(SET)或“请将此位置零”(CLEAR),将“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)

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

等等


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

请参阅https://www.kernel.org/doc/htmldocs/kernel-api/ch02s03.html

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计算机上都是原子的,并且有助于保持处理器之间的一致性。


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




bitwise-operators