How can I check my byte flag, verifying that a specific bit is at 1 or 0?

Question

I use a byte to store some flag like 10101010, and I would like to know how to verify that a specific bit is at 1 or 0.

Answer 1

Here's a function that can be used to test any bit:

bool is_bit_set(unsigned value, unsigned bitindex)
{
    return (value & (1 << bitindex)) != 0;
}

Explanation:

The left shift operator << creates a bitmask. To illustrate:

• (1 << 0) equals 00000001
• (1 << 1) equals 00000010
• (1 << 3) equals 00001000

So a shift of 0 tests the rightmost bit. A shift of 31 would be the leftmost bit of a 32-bit value.

The bitwise-and operator (&) gives a result where all the bits that are 1 on both sides are set. Examples:

• 1111 & 0001 equals 0001
• 1111 & 0010 equals 0010
• 0000 & 0001 equals 0000.

So, the expression:

(value & (1 << bitindex))

will return the bitmask if the associated bit (bitindex) contains a 1 in that position, or else it will return 0 (meaning it does not contain a 1 at the assoicated bitindex).

To simplify, the expression tests if the result is greater than zero.

• If Result > 0 returns true, meaning the byte has a 1 in the tested bitindex position.
• All else returns false meaning the result was zero, which means there's a 0 in tested bitindex position.

Note the != 0 is not required in the statement since it's a bool, but I like to make it explicit.

Answer 2

As an extension of Patrick Desjardins' answer:

When doing bit-manipulation it really helps to have a very solid knowledge of bitwise operators.

Also the bitwise "AND" operator in C is &, so you want to do this:

unsigned char a = 0xAA; // 10101010 in hex
unsigned char b = (1 << bitpos); // Where bitpos is the position you want to check

if(a & b) {
    //bit set
}

else {
    //not set
}

Above I used the bitwise "AND" (& in C) to check whether a particular bit was set or not. I also used two different ways of formulating binary numbers. I highly recommend you check out the Wikipedia link above.

Answer 3

You can use an AND operator. The example you have: 10101010 and you want to check the third bit you can do: (10101010 AND 00100000) and if you get 00100000 you know that you have the flag at the third position to 1.

Answer 4

Kristopher Johnson's answer is very good if you like working with individual fields like this. I prefer to make the code easier to read by using bit fields in C.

For example:

struct fieldsample
{
  unsigned short field1 : 1;
  unsigned short field2 : 1;
  unsigned short field3 : 1;
  unsigned short field4 : 1;
}

Here you have a simple struct with four fields, each 1 bit in size. Then you can write your code using simple structure access.

void codesample()
{
  //Declare the struct on the stack.
  fieldsample fields;
  //Initialize values.
  fields.f1 = 1;
  fields.f2 = 0;
  fields.f3 = 0;
  fields.f4 = 1;
  ...
  //Check the value of a field.
  if(fields.f1 == 1) {}
  ...
}

You get the same small size advantage, plus readable code because you can give your fields meaningful names inside the structure.

Answer 5

If you are using C++ and the standard library is allowed, I'd suggest storing your flags in a bitset:

#include <bitset>
//...
std::bitset<8> flags(someVariable);

as then you can check and set flags using the [] indexing operator.

Answer 6

Nobody's been wrong so far, but to give a method to check an arbitrary bit:

int checkBit( byte in, int bit )
{
  return in & ( 1 << bit );
}

If the function returns non-zero, the bit is set.

Answer 7

byte THIRDBIT = 4; // 4 = 00000100 i.e third bit is set

int isThirdBitSet(byte in) {
 return in & THIRDBIT; // Returns 1 if the third bit is set, 0 otherwise
}

Answer 8

You can do as Patrick Desjardins says and you make a bit-to-bit OR to the resulting of the previous AND operation.

In this case, you will have a final result of 1 or 0.

Answer 9

Traditionally, to check if the lowest bit is set, this will look something like:

int MY_FLAG = 0x0001;
if ((value & MY_FLAG) == MY_FLAG)
    doSomething();

Answer 10

Use a bitwise (not logical!) AND to compare the value against a bitmask.

if (var & 0x08) {
  /* The fourth bit is set */
}