Here is a simple example, note that each has a specific value to ensure that each matches a single bit in the 8-bit variable:

enum options {
  option_a = 0x01,  /*   1 == 00000001 */
  option_b = 0x02,  /*   2 == 00000010 */
  option_c = 0x04,  /*   4 == 00000100 */
  option_d = 0x08,  /*   8 == 00001000 */
  option_e = 0x10,  /*  16 == 00010000 */
  option_f = 0x20,  /*  32 == 00100000 */
  option_g = 0x40,  /*  64 == 01000000 */
  option_h = 0x80,  /* 128 == 10000000 */
};

So basically we have 8 boolean flags (0 off/false, 1 on/true). We can use these by utilising bitwise operations. There is really only 3 operations that you will use regularly on bit flags so lets see them.

Switching individual/multiple options “on” (or setting value true):

options |= option_a;
/* Translates to:
  options = options | option_a;
  options = 00000000 | 00000001;
  options = 00000001;
*/
 
options = option_a | option_c | option_h;
/* Translates to:
  options = 00000001 | 00000100 | 10000000;
  options = 10000101;
*/

Equally switching options “off” (or setting false) can be done as follows (note we are using the options from above, thus a, c and h are on):

options &= ~option_a;
/* Translates to:
  options = options & ~option_a;
  options = 10000101 & ~00000001;
  options = 10000101 & 11111110;
  options = 10000100;
*/

Obviously you need a basic grasp of boolean mathematics to be able to handle this but learning the basics shouldn’t be too hard. Finally the last thing to do is check to see if a flag is “on” or “off” (again using the options from before, so c and h are “on”:

if( options & option_b ) printf("B is ON\n");
/* 10000100 & 00000010 = 00000000 .. i.e. false, so no output */
if( options & option_c ) printf("C is ON\n");
/* 10000100 & 00000100 = 00000100 .. i.e. true, so "C is ON" is outputting */

As with most things in C, once you start using and abusing it should start to fall into place. I hope that this serves as a basic introduction to bit fields.

Let’s see how we’d do that:

#include <stdarg.h>
#include <stdio.h>
 
int Adding(int cnt, ...) {  /* the three ... indicate a variable list */
    int add, tmp, i;
    va_list args;            /* make a va_list */
    va_start(args, cnt);     /* variable list starts after 'cnt' */
    for(i = 0; i < cnt; i++) {
        tmp = va_arg(args, int); /* grab the next */
        add = add + tmp;         /* add to the sum */
    }
    va_end(args);    /* finished using variable list */
    return add;
}
 
int main( ) {
    int a;
    a = Adding(2, 1, 2);
    printf("%u\n", a);     /* Outputs 3 */
    a = Adding(3, 1, 2, 3);
    printf("%u\n", a);     /* Outputs 6 */
    return 0;
}

So the first argument indicates how many variables we are going to pass and the rest are summed together. The function Adding() would be identical in C++.

ENOTOBACCO		Read on an empty pipe
EBEFOREI		Invalid syntax
ECHERNOBYL		Core dumped
ECRAY			Program exited before being run
EDINGDONG		The daemon is dead
EFLAT			System needs tuning
EGEEK			Program written by inept Frat member
EIEIO			Here-a-bug, there-a-bug, ....
EIUD			Missing period
ELECTROLUX		Your code could stand to be cleaned up
EMILYPOST		Wrong fork
END.ARMS.CONTROL	Silo overflow
ENOHORSE		Mount failed
ENONSEQUETOR		C program not derived from main(){printf("Hello, world");}
EWATERGATE		Extended tape gap
EWOK			Aliens sighted
EWOK			Your code appears to have been stir-fried
EWOULDBNICE     	The feature you want has not been implemented yet

Not to be out done, a new signal:

SIGNUKE     	Nuclear event occurred (cannot be caught or ignored)