What are the benefits of enumeration types?

Answer 1

We use enumerations to identify a group of constants in a more meaningful way than would be possible with an integral type. Consider the following:

int toggle (int traffic_light)

{

if (traffic_light<0 traffic_light>3) return -1; // invalid argument!

traffic_light=traffic_light==3?0:traffic_light+1;

return traffic_light;

}

The int argument, traffic_light, gives us some indication as to its purpose, but the body of the function is difficult to read. It's difficult to digest the logic and the literal constant 3 looks suspiciously like a "magic number". Worse, the function returns errors through the return value.

Let's re-write the function with an enumerated type:

enum traffic_light {green, amber, red, red_amber};

traffic_light toggle (traffic_light current)

{

switch (current)

{

case green: current=amber; break;

case amber: current=red; break;

case red: current=red_amber; break;

default: current=green;

}

return current;

}

While the body of the function is more verbose, the logic is much clearer. We can see from the enumeration that a traffic_light object only has four possible states and that the function cycles from one state to the next, just as a real traffic light should.

Upon closer examination, we note that a traffic_light behaves exactly as if it we're a 2-bit unsigned integer and that all we're doing is incrementing the integer, cycling back to 0 when both bits are set. So we could effectively implement the toggle function with an operator overload:

traffic_light& operator++(traffic_light& lhs)

{

return lhs = (lhs==red_amber)?green:(traffic_light)(((int) lhs)+1);

}

Operator overloads are often difficult to read, however all operators must be intuitive; they should all work exactly as we expect them to work. The above actually replicates the middle line of the original function, casting to int to perform the increment.

With this in place, our toggle function becomes:

traffic_light toggle (traffic_light current)

{

return ++current;

}

Answer 2

User-defined enumeration types are most useful when a data type can take one of a small, discrete set of values, each of which have some meaning that is not a number. A favorite example in textbooks is a type for the suit of a playing card. There are four options: SPADE, CLUB, HEART, DIAMOND, and so we would make an enumeration type with these four entries. The main advantages are efficiency in storage (compared to e.g. storing these values as strings) and more readable code.