Understanding enum members' initialization with bitewise operators

What's operator<<?

Understanding operator<<, in this case, is very easy. What's on the left of the operator is the current value object; what's on the right is how many left shifts we should perform.

So for example, given a byte corresponding to 1:

0 0 0 0 0 0 0 1

a single shift to left would lead to:

0 0 0 0 0 0 1 0

Now, if we think of 1 as 2 ^ 0, at every left shift we are incrementing the exponent. Therefore the above byte is equal to 2 ^ 1 and so on:

0 0 0 0 0 0 0 1 // 2 ^ 0 = 1
0 0 0 0 0 0 1 0 // 2 ^ 1 = 2
0 0 0 0 0 1 0 0 // 2 ^ 2 = 4
0 0 0 0 1 0 0 0 // 2 ^ 3 = 8
...

What's operator&?

The binary operator& is the bitwise AND. For each corresponding bit of two bit sets, the resulting bit is 1 if both bits are 1, 0 otherwise. You can use it to check if, in a given bitset, a specific category is present. For example, let's consider category:

0 0 0 0 0 1 0 0

and let's consider a bitset that represents category 1 and 2, but not our category 3:

0 0 0 0 0 0 1 1

The bitwise AND between the two would give 0 (which is implicitly convertible to false):

0 0 0 0 0 1 0 0 &
0 0 0 0 0 0 1 1 =
0 0 0 0 0 0 0 0

On the other hand, if our bit set (now representing the first and third category) contained our category:

0 0 0 0 0 1 0 0 &
0 0 0 0 0 1 0 1 =
0 0 0 0 0 1 0 0

you would have a bitset representing a bit different from 0 (and therefore implicitly convertible to true).

Conclusion

If you represent every category as a single bit in a bit set, you can easily represent a group of categories in a single bit set.

Let's say that we want to represent the four letters A, C, G, T. We could assign a single bit in a bit set of length four:

0 0 0 1 // A
0 0 1 0 // C
0 1 0 0 // G
1 0 0 0 // T

Now let's forge a bitset that represents letters A and G:

0 1 0 1 // A + G

We can check if a given letter is in the bit set via &.

Is there an A?

0 1 0 1 & // A + G
0 0 0 1 = // A
0 0 0 1   // 1 ~ true

Yes, there is. Is there a C?

0 1 0 1 & // A + G
0 0 1 0 = // C
0 0 0 0   // 0 ~ false

Nope. Is there a G?

0 1 0 1 & // A + G
0 1 0 0 = // G
0 1 0 0   // 4 ~ true

Yes, there's. And finally, is there a T?

0 1 0 1 & // A + G
1 0 0 0 = // T
0 0 0 0   // 0 ~ false

No, there's not.

In general

Generally speaking, given a bit set a and the bit set b for the category we want to check for existence in a, the result of & can only be of two kinds:

1. 0
2. the value assigned to the category (a power of two)

In C++, testing for:

if (a & b)

can also be specified as:

if ((a & b) == a)

Practical example

Now you should be able to understand that given an enum like:

enum type
    { none              = 0
    , scene             = 1 << 0
    , player_aircraft   = 1 << 1
    , allied_aircraft   = 1 << 2
    , enemy_aircraft    = 1 << 3 };

and these variables:

auto a = scene;
auto b = enemy_aircraft;
auto c = player_aircraft;

the following:

    std::cout << "a is of type: " << ((a & scene) ? "scene" : "not scene") << '\n';    
    std::cout << "b is of type: " << ((b & enemy_aircraft) ? "enemy_aircraft" : "not enemy_aircraft") << '\n'; 
    std::cout << "c is of type: " << ((c & player_aircraft) ? "player_aircraft" : "not player_aircraft") << '\n'; 

will print:

a is of type: scene

b is of type: enemy_aircraft

c is of type: player_aircraft

Live demo