Enumerations: enum

An enum is a means of grouping together constants.
Each enumeration is a new literal type.
Classical enums are now referred to as unscoped enums ...

enum colour {red, green, blue};

C++11 introduces scoped enums, which looks more like ...

enum class lights {red, green, blue};

... and are sometimes called enum classes.

The idea is the names entered in the braces take on literal values.

The default values are 0 for the first, and 1 more than the previous for other entries.

So 0, 1, 2 for the example ...

enum colour {red, green, blue};
cout << red << endl;
cout << green << endl;
cout << blue << endl;

Unscoped generally

The general unscoped notation is

enum TypeName {...}

And once we have done this ...

enum colour {red, green, blue};

Declare and use variables of that type

colour hatColour;
hatColour = blue;

You don’t actually need the typename to set up the values but you then won’t have corresponding types:

enum {a, b, c};

You can set values as well:

enum {floatPrec = 6, doublePrec = 10, double_doublePrec = 10};

What if you set some?

enum {a = 4, b, c, d};

Or set some equal ...

enum {a = 4, b, c, d = 4};

Unscoped enums are accessible anywhere, scoped are not. The general notation for scoped ones:

enum class typename {... };

To access these values we need to use the scope resolution operator, so

typename::value.

Let’s look at an example. Set up a couple of enums, one unscoped and one scoped.

enum colour {red, yellow, green};
enum class peppers {red, yellow, green};

Which of these will work?

colour eyes = green;
peppers p1 = green;
colour hair = colour::red;
peppers p2 = peppers::red;

All but the second, where you try to initialise peppers with a colour.

enum type types: C++11

By default, scoped enums have int as the underlying type.

Best illustrated with an example from the textbook ...

enum intValues : unsigned long long {
charType = 255,
shortType = 65535,
intType = 65535,
longType = 4294967295UL,
long_longType = 18446744073709551615ULL
};

Unscoped enums don’t have a default type, just an integral large enough to hold the specified values.

Integral types: Non-floating on page 28, S2b.

This makes a difference when we use forward declaration for enums, which is allowed from C++11 on.

The underlying size must be specified and since unscoped doesn’t have a default we must be explicit for unscoped enums.

enum intValues : unsigned long long;
enum class open_modes;

Scoped are better than unscoped

Firstly, because the scoped ones better limit the likelihood of name clashes.

Secondly, because of the typing.

With unscoped enums the enumerators implicitly cast to integral types, then to floating if necessary.
This means you can pass an unscoped enum value to a function even though it’s representing something that should never to used as an integral or floating type.

showPrimeFactors(yellow);