ID : 216

viewed : 267

91

# Setting a bit

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

``number |= 1UL << n; ``

That will set the `n`th bit of `number`. `n` should be zero, if you want to set the `1`st bit and so on upto `n-1`, if you want to set the `n`th 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 `n`th 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 `n`th 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 `n`th bit of `number` into the variable `bit`.

# Changing the nth bit to x

Setting the `n`th 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); ``

or

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

or

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

`(number & ~(1UL << n))` will clear the `n`th bit and `(x << n)` will set the `n`th 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.

85

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.

73

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.

61

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

58

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.