Enumerations in C

An enum is a special type that represents a group of constants (unchangeable values). Enum is short for enumeration, which means specifically listed.

To create an enum, use the enum keyword, followed by the name of the enum, and separate the enum items with a comma:

enum Level {
  LOW,
  MEDIUM,
  HIGH
};

It is not required to use uppercase, but often considered as good practice.

To access the enum, you must create a variable of it.

Inside the main() method, specify the enum keyword, followed by the name of the enum (Level) and then the name of the enum variable (myVar in this example):

enum Level myVar;

Now that you have created an enum variable (myVar), you can assign a value to it. The assigned value must be one of the items inside the enum (LOW, MEDIUM or HIGH):

enum Level myVar = MEDIUM;

By default, the first item (LOW) has the value 0, the second (MEDIUM) has the value 1, etc. Therefore, if you now try to print myVar, it will output 1, which represents MEDIUM:

int main() {
  // Create an enum variable and assign a value to it
  enum Level myVar = MEDIUM;

  // Print the enum variable
  cout << myVar;

  return 0;
}

Changing the Default Values

As you know, the first item of an enum has the value 0. The second has the value 1, and so on. To make more sense of the values, you can easily change them like this:

enum Level { LOW = 25,
  MEDIUM = 50,
  HIGH = 75
};

Note that if you assign a value to one specific item, the next items will update their numbers accordingly:

enum Level {
  LOW = 5,
  MEDIUM, // Now 6
  HIGH // Now 7
};

Enum in a Switch Statement

Enums are often used in switch statements to check for corresponding values:

enum Level {
  LOW = 1,
  MEDIUM,
  HIGH
};

int main() {
  enum Level myVar = MEDIUM;

  switch (myVar) {
    case 1:
      cout << "Low Level";
      break;
    case 2:
      cout << "Medium level";
      break;
    case 3:
      cout << "High level";
      break;
  }
  return 0;
}

Forward Declaration of an enum in C++ 11

Forward declaration of enums is possible since C++11. Previously, the reason enum types couldn't be forward declared was because the size of the enumeration depended on its contents. As long as the size of the enumeration is specified by the application, it can be forward declared:

enum eye_colour_enum : unsigned int;
enum eye_colour_enum {black, brown, green, blue};

Notice that you do not need to specify the underlying type with an enum class:

enum class size_enum; // perfectly legal
enum size_enum {tiny, small, large};