As I mentioned it in the opening to this post: classical enumerations have a lot of drawbacks. Let me explicitly compare classical (unscoped) enumerations and scoped enumerations (sometimes called strongly typed enumerations), because this important comparison is not explicitly described in the rules.

Here is a classical enumeration:

enum Colour{
red,
blue,
green
};

Here are the drawbacks of the classical enumerations:

The enumerators have no scope

The enumerators implicitly convert to implicitly to int

The enumerators pollute the global namespace

The type of the enumerator is not defined. It just has to be big enough to hold the enumerator.

By using the keyword class or struct, the classical enumeration becomes a scoped enumeration (enum class):

enum class ColourScoped{
red,
blue,
green
};

Now, you have to use the scope operator for accessing the enumerators: ColourScoped::red. ColourScoped::red will not implicitly convert to int and will, therefore, not pollute the global namespace. Additionally, the underlying type is per default int.

After providing the background information we can directly jump into the rules.

Get your e-book at leanpub:

The C++ Standard Library

Concurrency With Modern C++

Get Both as one Bundle

With C++11,C++14, and C++17 we got a lot of new C++ libraries. In addition, the existing ones are greatly improved. The key idea of my book is to give you the necessary information to the current C++ libraries in about 200 pages.

C++11 is the first C++ standard that deals with concurrency. The story goes on with C++17 and will continue with C++20.

I'll give you a detailed insight in the current and the upcoming concurrency in C++. This insight includes the theory and a lot of practice with more the 100 source files.

Get my books "The C++ Standard Library" (including C++17) and "Concurrency with Modern C++" in a bundle.

In sum, you get more than 550 pages full of modern C++ and more than 100 source files presenting concurrency in practice.