opinions on enum class in C++11

[Elkvis]

let's say we have an enum

enum someEnum
{
    value1,
    value2
};

I'm finding myself hard pressed to find any real advantage to using the new C++11 features like so:

enum class someEnum : int
{
    value1,
    value2
};

I understand that this effectively requires the programmer to fully qualify the enum member name, but I, along with my colleagues are in the habit of fully qualifying enum member names, even pre-C++11. also, even though we've specified that the members use int as their backing storage, there is still no automatic conversion to int.

I'm just wondering if there is any common situation that makes the new way work better.

[manasij7479]

The few advantages I have personally encountered are:
1. You don't have to take measures(like declaring inside classes or namespaces) to isolate enum 'names' from the global/outer scope.
2. No need to clutter header files with multiple enum definitions at the top, just forward declare. (I'm not sure why this does not compile with old enums).
3. Sugar !

[Elysia]

No implicit conversions between two different enum types.

[kmdv]

If you want a practical example how to make use of the enum class scope, here is mine:

enum class Enum1
{
    Low_ = 100,
    A,
    B,
    C,
    High_
};

enum class Enum2
{
    Low_ = 200,
    A,
    B,
    C,
    D,
    High_
};

template <typename T>
T LoadEnumFromStream(typename std::underlying_type<T>::type x)
{
    typedef typename std::underlying_type<T>::type IntType;

    if (x <= static_cast<IntType>(T::Low_)
        || x >= static_cast<IntType>(T::High_))
    {
        throw 0; // Error.
    }
    return static_cast<T>(x);
}

...


Enum2 en = LoadEnumFromStream<Enum2>(1234);

This safely loads different enums from external storage.

[phantomotap]

No implicit conversions between two different enum types.

This is pretty much the only real advantage.

However, it is enough of an advantage that if you are already using C++11 features tying you into C++11 you should be using the new `enum' features as well.

Soma