What are flags and bitfields?

Question

Can someone explain to me what flags and bitfields are. They seems to be related to each other, or mabye i got the wrong idea. I kinda grasp bits and pieces of what they do and are but I would like to get them fully explain and I can't really find any good tutorials or guides.

I would be really thankful if someone could give some good examples on how to use them etc... For instance i see these kinds of expressions all the time and I dont fully understand them. Just that they are some kind of logical operators or something

  VARIABLE1 | VARIABLE2

Thanks in advance!

Have you read wikipedia article on the subject? See http://en.wikipedia.org/wiki/Bit_field — j.karlsson, Mar 10 '13 at 01:00

score 4 · Answer 1 · answered Mar 10 '13 at 01:18

An introduction to bitwise operations can be found here: http://www.codeproject.com/Articles/2247/An-introduction-to-bitwise-operators

As they apply to flags, bitwise operations are advantageous in that they are very fast and save on space. You can store many different states of an object within a single variable by using mutually exclusive bits. i.e.

0001 // property 1 (== 1, 0x01)
0010 // property 2 (== 2, 0x02)
0100 // property 3 (== 4, 0x04)
1000 // property 4 (== 8, 0x08)

These can represent four different properties of an object (these are the "masks"). We can add a property to an object's flags state by using or:

short objState = 0; // initialize to 0
objState |= 0010;

This adds property 2 above to objState by "or"-ing 0010 with 0000, resulting in 0010. If we add another flag/property like so:

objState |= 0100;

we end up with objState = 0110.

Now we can check if the object has the flag for property 2 set, for example, by using and:

if (objState & 0010) // do something

and is 1 if and only if both bits are 1, so if bit 2 is 1, the above operation is guaranteed to be non-zero.

So as I mentioned, the advantages of this way of handling properties/flags of an object is both speed and efficiency. Think of it this way: you can store a set of properties in a single variable using this method.

Let's say, for example, you have a file type and you wish to keep track of the properties using bit masks (I'll use audio files). Maybe bits 0 - 3 can store the bit-depth of the file, bits 4 - 7 can store the file type (Wav, Aif, etc.), and so on. You then just need this one variable to pass around to different functions and can test using your defined bit-masks instead of having to keep track of potentially dozens of variables.

Hope that sheds some light on at least this one application of bitwise operation.

score 1 · Answer 2 · answered Mar 10 '13 at 01:16

A "bifield" is a set one or more bits in a "word" (that is, say an int, long or char) that are stored together in one variable.

You can for example have "none, "spots" and/or "stripes" on some animal, and it can also have "none, short, medium or long" tail.

So, we need two bits to reprent the length of a tail:

enum tail
{
   tail_none = 0,
   tail_short = 1, 
   tail_medium = 2, 
   tail_long = 3
};

We then store these as bits in the "attributes":

enum bits_shifts
{
   tail_shift = 0,    // Uses bits 0..1
   spots_shift = 2,   // Uses bit 2
   stripes_shift = 3
};


enum bits_counts
{
   tail_bits = 2,    // Uses bits 0..1
   spots_bits = 1,   // Uses bit 2
   stripes_bits = 1
};

We now pretend that we have fetched from some input the tail_size and the has_stripes, has_spots variables.

int attributes;

attributes = tail_length << tail_shift;

if (has_spots)
{
   attributes |= 1 << spots_shift;
}

if (has_stripes)
{
   attributes |= 1 << stripes_shift;
}

Later we want to figure what the attributes are:

switch((attributes >> tail_shift) & (1 << tail_bits)-1))
{
   case tail_none:
     cout << "no tail";
     break;

   case tail_short:
     cout << "short tail";
     break;

   case tail_medium:
     cout << "medium tail";
     break;

   case tail_short:
     cout << "long tail";
     break;
 }

 if (attributes & (1 << stripes_shift))
 {
    cout << "has stripes";
 }


 if (attributes & (1 << spots_shift))
 {
    cout << "has spots";
 }

Now, we have stored all this in one integer, and then "fished it out" again.

You can of course do something like this too:

enum bitfields
{
    has_widget1 = 1,
    has_widget2 = 2,
    has_widget3 = 4, 
    has_widget4 = 8, 
    has_widget5 = 16,
    ...
    has_widget25 = 16777216, 
    ...
}

int widgets = has_widget1 | has_widget5;

... 

if (widgets & has_widget1)
{
  ... 
}

It is really just an easy way to pack several things into one variable.

score 0 · Answer 3 · answered Mar 10 '13 at 00:57

the bits of an integer value can be used as bools.

http://msdn.microsoft.com/en-us/library/yszfawxh(v=vs.80).aspx

Make with | and retrieve with &.

enum { ENHANCED_AUDIO = 1, BIG_SPEAKERS = 2, LONG_ANTENNA = 4};

foo(HAS_CAR | HAS_SHOE); // equiv to foo(3);

void processExtraFeatures(flags) {
    BOOLEAN enhancedAudio = flags & ENHANCED_AUDIO; // true
    BOOLEAN bigSpeakers = flags & BIG_SPEAKERS; // true
    BOOLEAN longAntenna = flags & LONG_ANTENNA; // false
}

score 0 · Answer 4 · edited Mar 10 '13 at 01:17

0

A "flag" is a notional object that can be set or not set, but not a part of the c++ language.

A bitfield is a language construct for using sets of bits that may not make up an addressable object. Fields of a single bit are one---often very good---way of implementing a flag.

edited Mar 10 '13 at 01:17

David G

94,763
41
167
253

answered Mar 10 '13 at 01:09

dmckee --- ex-moderator kitten

98,632
24
142
234

What are flags and bitfields?

4 Answers4