Node:Masks, Previous:Bitwise exclusive OR (XOR/EOR), Up:Truth tables and bit masks


Bit strings and bitwise operators are often used to make masks. A mask is a bit string that "fits over" another bit string and produces a desired result, such as singling out particular bits from the second bit string, when the two bit strings are operated upon. This is particularly useful for handling flags; programmers often wish to know whether one particular flag is set in a bit string, but may not care about the others. For example, you might create a mask that only allows the flag of interest to have a non-zero value, then AND that mask with the bit string containing the flag.

Consider the following mask, and two bit strings from which we want to extract the final bit:

mask   = 00000001
value1 = 10011011
value2 = 10011100

mask & value1 == 00000001
mask & value2 == 00000000

The zeros in the mask mask off the first seven bits and only let the last bit show through. (In the case of the first value, the last bit is 1; in the case of the second value, the last bit is 0.)

Alternatively, masks can be built up by operating on several flags, usually with inclusive OR:

flag1 = 00000001
flag2 = 00000010
flag3 = 00000100

mask = flag1 | flag2 | flag3

mask == 00000111

See Opening files at a low level, for a code example that actually uses bitwise OR to join together several flags.

It should be emphasized that the flag and mask examples are written in pseudo-code, that is, a means of expressing information that resembles source code, but cannot be compiled. It is not possible to use binary numbers directly in C.

The following code example shows how bit masks and bit-shifts can be combined. It accepts a decimal number from the user between 0 and 128, and prints out a binary number in response.

#include <stdio.h>
#define NUM_OF_BITS 8

/* To shorten example, not using argp */
int main ()
  char *my_string;
  int input_int, args_assigned;
  int nbytes = 100;
  short my_short, bit;
  int idx;

  /* This hex number is the same as binary 10000000 */
  short MASK = 0x80;

  args_assigned = 0;
  input_int = -1;

  while ((args_assigned != 1) ||
	 (input_int < 0) || (input_int > 128))
      puts ("Please enter an integer from 0 to 128.");
      my_string = (char *) malloc (nbytes + 1);
      getline (&my_string, &nbytes, stdin);
      args_assigned = sscanf (my_string, "%d", &input_int);
      if ((args_assigned != 1) ||
	  (input_int < 0) || (input_int > 128))
	puts ("\nInput invalid!");

  my_short = (short) input_int;

  printf ("Binary value = ");

     Convert decimal numbers into binary
     Keep shifting my_short by one to the left
     and test the highest bit.  This does
     NOT preserve the value of my_short!

  for (idx = 0; idx < NUM_OF_BITS; idx++)
      bit = my_short & MASK;
      printf ("%d", bit/MASK);
      my_short <<= 1;

  printf ("\n");
  return 0;