c++ - How do you set, clear, and toggle a single bit?

ID : 216

viewed : 98

Tags : c++cbit-manipulationbitwise-operatorsc++c

Top 5 Answer for c++ - How do you set, clear, and toggle a single bit?

vote vote


Setting a bit

Use the bitwise OR operator (|) to set a bit.

number |= 1UL << n; 

That will set the nth bit of number. n should be zero, if you want to set the 1st bit and so on upto n-1, if you want to set the nth bit.

Use 1ULL if number is wider than unsigned long; promotion of 1UL << n doesn't happen until after evaluating 1UL << n where it's undefined behaviour to shift by more than the width of a long. The same applies to all the rest of the examples.

Clearing a bit

Use the bitwise AND operator (&) to clear a bit.

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

That will clear the nth bit of number. You must invert the bit string with the bitwise NOT operator (~), then AND it.

Toggling a bit

The XOR operator (^) can be used to toggle a bit.

number ^= 1UL << n; 

That will toggle the nth bit of number.

Checking a bit

You didn't ask for this, but I might as well add it.

To check a bit, shift the number n to the right, then bitwise AND it:

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

That will put the value of the nth bit of number into the variable bit.

Changing the nth bit to x

Setting the nth bit to either 1 or 0 can be achieved with the following on a 2's complement C++ implementation:

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

Bit n will be set if x is 1, and cleared if x is 0. If x has some other value, you get garbage. x = !!x will booleanize it to 0 or 1.

To make this independent of 2's complement negation behaviour (where -1 has all bits set, unlike on a 1's complement or sign/magnitude C++ implementation), use unsigned negation.

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


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

It's generally a good idea to use unsigned types for portable bit manipulation.


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

(number & ~(1UL << n)) will clear the nth bit and (x << n) will set the nth bit to x.

It's also generally a good idea to not to copy/paste code in general and so many people use preprocessor macros (like the community wiki answer further down) or some sort of encapsulation.

vote vote


Using the Standard C++ Library: std::bitset<N>.

Or the Boost version: boost::dynamic_bitset.

There is no need to roll your own:

#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 

The Boost version allows a runtime sized bitset compared with a standard library compile-time sized bitset.

vote vote


The other option is to use bit fields:

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

defines a 3-bit field (actually, it's three 1-bit felds). Bit operations now become a bit (haha) simpler:

To set or clear a bit:

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

To toggle a bit:

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

Checking a bit:

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

This only works with fixed-size bit fields. Otherwise you have to resort to the bit-twiddling techniques described in previous posts.

vote vote


I use macros defined in a header file to handle bit set and clear:

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


It is sometimes worth using an enum to name the bits:

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

Then use the names later on. I.e. write

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

to set, clear and test. This way you hide the magic numbers from the rest of your code.

Other than that I endorse Jeremy's solution.

Top 3 video Explaining c++ - How do you set, clear, and toggle a single bit?