C++ – Do We Really Need ‘enum class’ in C++11?

enum class is called a scoped enumeration. It prevents polluting the namespace where the enumeration appears with the names of the enumerators.

In C++03, you could do effectively the same thing by putting the enum inside a dedicated class. Perhaps that's the source of the syntax, which is a bit confusing.

Another difference is that the enumerators of such a type don't convert implicitly to int (static_cast<int> is required). This may be seldom needed but it makes it safe to overload a function taking an int argument with one taking enum type. You can be sure the int won't be called by accident. Or you can define pseudo-integral types with dedicated operator functions, and be sure that built-in operators won't interfere.

It's a bit annoying that these two unrelated differences come in the same package, and that you can't get an unscoped enumeration with no implicit conversion, but generally both changes are Good Things and enum class is a good default practice in C++11.

EDIT: A scoped enumeration is defined like this:

enum class duck { huey, dewey, louie };

and must be used with the scope resolution operator :: like this:

duck culprit = duck::huey; // or "auto culprit" to avoid redundancy

Note that the :: operator also works with C++03 unscoped enumerations, so the second line above would work even if the first was missing class.

This might be excessive detail, but class does not go into the elaborated-type-specifier if forward declaring the enumerated type, as in

void quack( enum duck whom ); // not "enum class"

However, there is a construct new in C++11, the opaque-enum-declaration, which does include the class keyword and defines a complete type.

enum duck; // duck is declared as incomplete type
enum class duck; // duck is now complete type; underlying type defaults to int

The keyword struct can be substituted for class with no semantic difference.

C++ has two kinds of enum:

1. enum classes
2. Plain enums

Here are a couple of examples on how to declare them:

 enum class Color { red, green, blue }; // enum class
 enum Animal { dog, cat, bird, human }; // plain enum 

What is the difference between the two?

• enum classes - enumerator names are local to the enum and their values do not implicitly convert to other types (like another enum or int)

• Plain enums - where enumerator names are in the same scope as the enum and their values implicitly convert to integers and other types

Example:

enum Color { red, green, blue };                    // plain enum 
enum Card { red_card, green_card, yellow_card };    // another plain enum 
enum class Animal { dog, deer, cat, bird, human };  // enum class
enum class Mammal { kangaroo, deer, human };        // another enum class

void fun() {

    // examples of bad use of plain enums:
    Color color = Color::red;
    Card card = Card::green_card;

    int num = color;    // no problem

    if (color == Card::red_card) // no problem (bad)
        cout << "bad" << endl;

    if (card == Color::green)   // no problem (bad)
        cout << "bad" << endl;

    // examples of good use of enum classes (safe)
    Animal a = Animal::deer;
    Mammal m = Mammal::deer;

    int num2 = a;   // error
    if (m == a)         // error (good)
        cout << "bad" << endl;

    if (a == Mammal::deer) // error (good)
        cout << "bad" << endl;

}

Conclusion:

enum classes should be preferred because they cause fewer surprises that could potentially lead to bugs.