What is the use of enums in C and C++

Question

Enum is list of constant integer values. It can be used instead of defining constant values using #define. But other than that, I haven't found any substantial uses of enums in C and CPP. Can any one please let me know what are the exact uses of enums.

Initially I thought if we create a enum variable and assign a value which is not in the enum values, the compiler will shout. But that is not true. We can assign any value to the enum variable. I can't think of any substantial uses of enum.

Answer 1

Enums are very useful in programming, because they make your code both more readable and more consistent.

For instance: say that we have the following switch statement:

switch(fruit)
{
    case 1:
        // code goes here
        break;
    case 2:
        // code goes here
        break;
    case 3:
        // code goes here
        break;
    default:
        // code goes here
        break;
}

It would be far more clear, if you had define an enum fruit that would contain the fruits you have and then use it the following way:

switch(fruit)
{
    case fruits::apple:
        // code goes here
        break;
    case fruits::orange:
        // code goes here
        break;
    case fruits::banana:
        // code goes here
        break;
    default:
        // code goes here
        break;
}

where fruits is an enum.

enum fruits { apple, orange, banana };

Compare now the first snippet to the second one. The second is more readable and in addition to that you don't have to remember that 1 is for apple, 2 for banana and so on.

Answer 2

Advantages over macros

• Debuggers can print names for values
• Your constants will be scoped (if you want, you can put them also in a namespace in C++)
• The compiler can warn if you forget an enum constant in a switch
• Values for the constants are automatically assigned, if you don't give explicit values
• The enum type is always large enough to hold all the constants. When using #define, you have to commit to int or some typedef and ensure that all the constants fit manually

Answer 3

An enum isn't that much different from a #define, in addition to what others have already said, the main difference to me is this:

You can group constants together

Also, an enum has an underlying type which can be specified to your needs. In C++11 you can use enum class to get a strong typed and scoped enum which makes enums even more useful.

In general, try to avoid the preprocessor as much as you can as it doesn't have any idea about the code and what it's trying to do. Instead of using a define for a single constant, consider writing:

const int MY_CONSTANT = 42;

(and all its static, member or namespace variants of defining a typed constant)