The beginner's guide to using enum Flags

• Download sample source - 0.9 Kb
• Download console demo- 17.3 Kb

Introduction

One time I was roaming the Visual C++ forum (once again), I had to face the facts that bitwise operations, and binary in general, are rarely in beginners common sense. After having painned my fingers to write a long long answer to that innocent person, It became obvious that i had to share this obfuscated knowledge with the community through this article.

if you want to get deeper knowledge about the C/C++ bitwise operators cover, you can read the very complete article An introduction to bitwise operators by PJ Arends. You can also go into a very complex (but effective) analysis of bit hacking with this article: Bit Twiddling Hacks By Sean Eron Anderson.

I'm so going to present the more complete way as I can what we can do with bitwise operators, flags and all that binary stuff.

The Facts

One of the places where we most find the use for this is certainly when a library provides a set of enumerations and when functions use DWORD as a flags container. Let's take for that article the example of an enum which defines some styles :

enum {
    STYLE1 =   1,
    STYLE2 =   2,
    STYLE3 =   4,
    STYLE4 =   8,
    STYLE5 =  16,
    STYLE6 =  32,
    STYLE7 =  64,
    STYLE8 = 128
};

As we can see, these constant are all powers of 2. To understand why these constants' are chosen, we must go in binary representation :

   1 -> 0b 00000000 00000000 00000000 00000001
   2 -> 0b 00000000 00000000 00000000 00000010
   4 -> 0b 00000000 00000000 00000000 00000100
   8 -> 0b 00000000 00000000 00000000 00001000
  16 -> 0b 00000000 00000000 00000000 00010000
  32 -> 0b 00000000 00000000 00000000 00100000
  64 -> 0b 00000000 00000000 00000000 01000000
 128 -> 0b 00000000 00000000 00000000 10000000

Notice that for all of these values, only one bit is set at a time, all the others are equal to 0. You now can see appearing a high interrest in this, which is that each bit is used as a flag for a functionnality (here, each bit represents a style). We can now imagine a way to mix the flags together in one variable, to avoid using as many booleans as we need flags. Consider the following example :

 0b 00000000 00000000 00000000 00100101

 Flags of Style1, Style3 and Style6 are set

The Operators

We face a problem now. C++ doesn't handle binary directly. We have to use bitwise operators instead. There are 3 atomic bitwise operators to know, presented by ascending order of priority : OR (|), AND (&) and NOT (~). Here are their behaviors:

  x y  |        x y  &        x  ~
 --------      --------      ------
  0 0  0        0 0  0        0  1
  0 1  1        0 1  0        1  0
  1 0  1        1 0  0
  1 1  1        1 1  1

Knowing this, we can use these operators to build some mixes such as presented above.
In the case of the instruction STYLE1 | STYLE3 | STYLE6, we so OR the constants like this:

 0b 00000000 00000000 00000000 00000001     <- STYLE1
 0b 00000000 00000000 00000000 00000100     <- STYLE3
 0b 00000000 00000000 00000000 00100000     <- STYLE6
-----------------------------------------------
 0b 00000000 00000000 00000000 00100101     <- STYLE1 | STYLE3 | STYLE6

We can see that the bitwise OR operator is pretty like the addition (+) operator. However, you have to be very careful if you wished to use + instead or |. The reason is simple: adding 1 + 1 resolves into 0 (plus one carry over 1). You won't see any problem if all the constants are strictly different though, but i won't go deeper as it is a bad practice to use other than bitwise operators when processing binary operations.

DWORD in action

Commonly, such mixes stick to the DWORD type. However, this is not a must as we can do this with any integer types (char, short, int, long...). A DWORD is an unsigned 32 bits integer (like those used in the binary representations of this article). Let's imagine the case when we have such a DWORD constructed in a function, and passed to another in parameter. How can the called function know which bits are set, and which are not? Easy... Follow me !

Say we want to know if the bit of STYLE8 is set in the DWORD passed in parameter. We must have a mask which we will AND parameter. In practice, the mask is the same as the constant we are about to test, so there's no additional code to create such a mask:

 DWORD parameter   ->   0b 00000000 00000000 00000000 00100101
 STYLE8 mask       ->   0b 00000000 00000000 00000000 10000000
                       ----------------------------------------
 Bitwise AND       ->   0b 00000000 00000000 00000000 00000000     <- 0x00000000
 
 
 
 DWORD parameter   ->   0b 00000000 00000000 00000000 10100101
 STYLE8 mask       ->   0b 00000000 00000000 00000000 10000000
                       ----------------------------------------
 Bitwise AND       ->   0b 00000000 00000000 00000000 10000000     <- STYLE8

If the AND operation returns 0, then, the bits was not set, otherwise, you get the mask you applied.

OK, now, in practice, here is how you'll often see it:

void SetStyles(DWORD dwStyles) {
    if ((STYLE1 & dwStyles) == STYLE1) {
        //Apply style 1

    }
    else if ((STYLE2 & dwStyles) == STYLE2) {
        //Apply style 2

    }
    else if ((STYLE3 & dwStyles) == STYLE3) {
        //Apply style 3

    }
    //etc...

}

I didn't present the third operator NOT (~) yet. It is generally used when you have a set of bits, in which some are set and some aren't, and where you'd like to remove one of them. The sample of code below exposes how this can be done:

void RemoveStyle5 (DWORD& dwStyles) {
    if ((STYLE5 & dwStyles) == STYLE5) {
        dwStyles &= ~STYLE5;
    }
}

I didn't mention the XOR ( ^ ) operator yet. The reason why it comes last is for the only reason that this operator is not atomic, that means that we can reproduce its behavior with the other operators presented already:

#define XOR(a,b) (((a) & ~(b)) | ((b) & ~(a)))

Anyway, this operator can be used to easily switch one bit :

void SwitchStyle5 (DWORD& dwStyles) {
    dwStyles ^= STYLE5;
}

Links

The following links are for a complimentary knowledge, if you like to go deeper in bitwise handling:

• An introduction to bitwise operators by PJ Arends.
• Bit Twiddling Hacks by Sean Eron Anderson.

Conclusion

Well, here we are then. If you went here to understand these binary operations, I hope that i helped you in your way. if you came to see what was going on here, then don't hesitate to point my mistakes if any, so that i can fastly fix it.