C++ Assigning Enums explicit values using bit shifting

Question 1

The usual reason for doing this is to associate each enum value with a single bit of a final v value, so you can (for one example) encode a number of flags into a single variable.

For example, with a typical 32-bit system, you can encode (obviously enough) 32 individual flags into a single 32-bit int (or, preferably, unsigned int).

For example, if you're looking at keys on the keyboard, you could encode "normal" keys like letters and digits into one byte (probably using consecutive values, as you've suggested), and "modifier" keys like shift, alt, and control as individual bits. This will allow you (for example) to encode something like control+alt+A as a single value.

Likewise, for mouse messages you could treat the mouse buttons as "modifiers", so you could encode something like dragging the mouse as a single value.

In both cases, the important point of encoding the "modifiers" as individual bits is that this allows you to later retrieve those modifiers unambiguously -- if the right bit is set in the value, then that modifier was use. By contrast, if you just use consecutive numbers, you can't extract individual pieces afterwards. For example, if you have inputs encoded as 1, 2 and 3, you can't tell whether a 3 is intended to indicate an original input corresponding to 3, or inputs of both 1 and 2 at the same time. If, however, you encode the values as 1, 2 and 4, you can combine values, and still decode them, so you can see exactly what input(s) were necessary to produce a particular value.

Question 2

It's one of those cases where, because a thing can be implemented in C++, no mechanism to implement it explicitly is added.

enums provide linker/debugger visible constants and can be scoped into classes and templates, so while it doesn't quite do what the end-user is trying to achieve, and certainly doesn't explicitly do it, the fact that the values in an enum expression don't have to be sequential means that it's considered sufficient for implementing enumerated bit masks.

The resulting values can be used directly in bit masks, such as:

    enum {
        Widget = 1 << 0,  // value b00000001
        Dingo = 1 << 1,   // value b00000010
        Herp = 1 << 2     // value b00000100
    };

    if (flag & Widget)
        doWidgetThings();
    if (flag & Dingo)
        feedTheDog(baby);
    if (flag & Herp)
        win();

This is capable of accepting 0, 1 or more values in "flag" at once:

    flag = 0; // matches none
    flag = Herp; // matches one flag.
    flag = Widget | Dingo; // sets flag to have both widget and dingo.

Question 3

The reason you would want to do this is because you can use enums defined this way as bitmasks. Given a 32-bit integer, you could have 32 unique characteristics that could all be enabled or disabled using bit-wise combinations of the enumerated values.

For instance, if you wanted to create an event handler that listened for QUIT_APPLICATION and CLOSE_WINDOW in the implementation that uses bit-shifts, you could simply use QUIT_APPLICATION | CLOSE_WINDOW. Each enum is a single bit, and combining them together allows you to easily specify every type of event you wanted in a way that you could not do if they were simply enumerated from 1-16.

Think about the case where you wanted an event handler that listened for PUSH and RELEASE using your proposed "more efficient" enum. If you were to OR these together you would get 3. 3 is also the value of DOUBLECLICK in your example. So there is no way to know which events you really wanted; was it the combination of PUSH and RELEASE or was it simply DOUBLECLICK? That is why reserving a single bit for each of the enumerated types is so powerful.

You will often see enumerated values defined like this:

enum EventType {
    NONE                =       0,
    PUSH                =     0x1,
    RELEASE             =     0x2,
    DOUBLECLICK         =     0x4,
    DRAG                =     0x8,
    MOVE                =    0x10,
    KEYDOWN             =    0x20,
    KEYUP               =    0x40,
    FRAME               =    0x80,
    RESIZE              =   0x100,
    SCROLL              =   0x200,
    PEN_PRESSURE        =   0x400,
    PEN_ORIENTATION     =   0x800,
    PEN_PROXIMITY_ENTER =  0x1000,
    PEN_PROXIMITY_LEAVE =  0x2000,
    CLOSE_WINDOW        =  0x4000,
    QUIT_APPLICATION    =  0x8000,
    USER                = 0x10000
};

Sometimes you will even see things like:

    ...
    CLOSE_WINDOW        =  0x4000,
    QUIT_APPLICATION    =  0x8000,
    CLOSE_AND_QUIT      =  CLOSE_WINDOW | QUIT_APPLICATION,
    ...

The bitshift notation is just easier to read (for some people), they both do the same thing. Each enumerated value represents a single bit or discrete combination of bits (except for NONE, which represents the absence of all bits).