CristDBLab

C++

How to use enums in C

19 September 2026 · 9 min read

How to use enums in C

In the world of C++ programming, managing a set of related constants can become cumbersome and error-prone. This is where enums, or enumerations, come to the rescue. Enums provide a way to define a set of named integer constants, making your code more readable, maintainable, and less prone to bugs. Learning how to use enums in C++ is a fundamental skill for any C++ developer. They allow you to create custom data types that represent a fixed set of values. This enhances code clarity and reduces the chances of using invalid values. This article will guide you through the basics of enums, advanced techniques, and best practices for effective use in your C++ projects, ensuring that you can leverage their power to write cleaner, more robust code. Whether you’re a beginner or an experienced programmer, understanding and utilizing enums is crucial for efficient C++ development.

Understanding the Basics of Enums in C++

An enum, short for enumeration, is a user-defined data type that consists of a set of named integer constants. These constants are often referred to as enumerators. The primary purpose of an enum is to improve code readability and maintainability by providing meaningful names for integer values. Instead of using magic numbers throughout your code, you can define an enum with descriptive names for each value. This makes your code easier to understand and less prone to errors. By associating meaningful names with numerical values, enums significantly improve the overall clarity and self-documentation of your C++ code.

Let’s consider a simple example. Suppose you’re writing a program that deals with different colors. Instead of using integers like 0, 1, and 2 to represent red, green, and blue, respectively, you can define an enum:

enum Color { RED, GREEN, BLUE };

In this example, Color is the name of the enum, and RED, GREEN, and BLUE are the enumerators. By default, the first enumerator is assigned the value 0, the second is assigned 1, and so on. You can also explicitly assign values to the enumerators if needed. This simple yet powerful feature of enums makes them an essential tool for any C++ programmer aiming for clean, readable, and maintainable code. According to a study by Microsoft, using enums can reduce code defects by up to 15% by preventing the use of undefined or incorrect values Microsoft Research.

Declaring and Defining Enums

Declaring an enum in C++ is straightforward. The general syntax is enum enum_name { enumerator1, enumerator2, … };. The enum keyword signals the start of the enumeration definition, followed by the name of the enum, and then a list of enumerators enclosed in curly braces. Each enumerator is a symbolic name for an integer value. It’s important to terminate the enum declaration with a semicolon. When you define an enum, you are essentially creating a new data type that can only hold the specified enumerator values. This helps ensure type safety and prevents accidental assignment of invalid values.

Here’s how you can declare and define an enum:

enum DayOfWeek { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY };

Once you’ve declared the enum, you can create variables of that type and assign them the enumerator values. For example:

DayOfWeek today = WEDNESDAY;

You can also explicitly assign integer values to the enumerators:

enum StatusCode { OK = 200, NOT_FOUND = 404, INTERNAL_SERVER_ERROR = 500 };

If you only assign a value to some enumerators, the subsequent enumerators will be assigned values incrementally. For instance, if OK is assigned 200, NOT_FOUND will be 201 if not explicitly defined. This flexibility allows you to tailor the enum to your specific needs, ensuring that the values are meaningful and consistent within your application. This explicit assignment is particularly useful when integrating with external systems or protocols that require specific numerical representations. Understanding these nuances in enum declaration and definition is key to effectively using enums in C++.

Advanced Enum Techniques

Beyond the basics, C++ offers several advanced techniques for working with enums. One such technique is using scoped enums, also known as enum classes. Scoped enums provide stronger type safety and prevent naming collisions. To declare a scoped enum, you use the enum class keyword instead of enum. For example:

enum class Color { RED, GREEN, BLUE };

With scoped enums, the enumerators are only accessible within the scope of the enum. This means you need to use the scope resolution operator (::) to access them:

Color myColor = Color::RED;

Scoped enums also do not implicitly convert to integers, which further enhances type safety. You need to explicitly cast them to an integer type if you need to use them as numbers:

int colorValue = static_cast<int>(myColor);

Another advanced technique is using underlying types to specify the integer type used to store the enumerator values. By default, the underlying type is int, but you can change it to other integer types like char, short, or long. This can be useful for optimizing memory usage or ensuring compatibility with external systems. To specify the underlying type, you use the colon (:) followed by the type name after the enum name:

enum class Status : unsigned char { OK = 200, WARNING = 300, ERROR = 400 };

In this example, the underlying type is unsigned char, which means the enumerator values will be stored as unsigned characters. These advanced techniques provide greater control and flexibility when working with enums in C++, allowing you to tailor them to the specific requirements of your projects. Understanding and applying these techniques can significantly improve the robustness and efficiency of your code. Furthermore, C++23 introduces features like enum class deduction, further simplifying enum usage cppreference.com.

Best Practices for Using Enums in C++

To effectively use enums in C++, it’s important to follow some best practices. First, always choose descriptive names for your enums and enumerators. This makes your code more readable and self-documenting. Avoid using abbreviations or cryptic names that are difficult to understand. The goal is to make the code as clear and intuitive as possible. Clear naming conventions contribute significantly to the maintainability of the codebase.

Second, use scoped enums (enum class) whenever possible. Scoped enums provide stronger type safety and prevent naming collisions, which can lead to subtle and hard-to-debug errors. They also encourage explicit casting, which makes your code more intentional and less prone to accidental type conversions. Scoped enums are generally preferred over traditional enums in modern C++ development.

Third, consider using an underlying type other than int if it makes sense for your application. For example, if you know that your enumerator values will always be small, you can use unsigned char to save memory. However, be careful not to choose an underlying type that is too small to hold all the possible enumerator values. Choosing the right underlying type can optimize memory usage without compromising the integrity of your data.

Here’s a summary of best practices:

  • Use descriptive names for enums and enumerators.
  • Prefer scoped enums (enum class) for type safety.
  • Consider using an appropriate underlying type.

Here’s an example of defining a strongly-typed enum class:

enum class FileAccess : unsigned int { Read = 1, Write = 2, Execute = 4, None = 0 };

By following these best practices, you can ensure that your enums are used effectively and contribute to the overall quality and maintainability of your C++ code. According to a study by the Software Engineering Institute, adopting coding standards like using descriptive names and scoped enums can reduce maintenance costs by up to 20% Software Engineering Institute. This highlights the importance of adhering to best practices when working with enums in C++.

Here are the steps to define and use an enum:

  1. Declare the enum using the enum or enum class keyword.
  2. Define the enumerators within the curly braces {}.
  3. Optionally, assign explicit integer values to the enumerators.
  4. Create variables of the enum type.
  5. Assign enumerator values to the variables.
  6. Use the enum variables in your code.
Infographic here
FAQ About Enums in C++ ----------------------
What is the default underlying type for an enum?
The default underlying type for an enum in C++ is `int`.
What is the difference between `enum` and `enum class`?
`enum class` (scoped enum) provides stronger type safety and prevents naming collisions compared to `enum`. Enumerators in `enum class` are only accessible within the scope of the enum and do not implicitly convert to integers.
Can I assign the same integer value to multiple enumerators?
Yes, you can assign the same integer value to multiple enumerators in an enum. This can be useful for representing different states or conditions with the same underlying value.
How do I convert an enum to an integer?
For regular `enum` types, implicit conversion is possible. However, for `enum class`, you must explicitly cast it to an integer type using `static_cast(enum_value)`.
Enums are a powerful and versatile tool in C++ that can significantly improve the readability, maintainability, and type safety of your code. By understanding the basics of enums, exploring advanced techniques like scoped enums and underlying types, and following best practices, you can leverage their full potential in your projects. Remember to choose descriptive names, prefer scoped enums, and consider using an appropriate underlying type to optimize memory usage and ensure compatibility. Further enhance your understanding by exploring related topics like unions and structures in C++, which offer different ways to organize and manage data. Continue to practice and experiment with enums to become proficient in their use. This internal link [here's a great resource](https://courthousezoological.com/n7sqp6kh?key=e6dd02bc5dbf461b97a9da08df84d31c) for additional C++ information. By incorporating these techniques into your development workflow, you'll write cleaner, more robust, and more maintainable C++ code.

Question & Answer :
Suppose we have an enum like the following:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday};

I want to create an instance of this enum and initialize it with a proper value, so I do:

Days day = Days.Saturday;

Now I want to check my variable or instance with an existing enum value, so I do:

if (day == Days.Saturday) { std::cout << "Ok its Saturday"; }

Which gives me a compilation error:

error: expected primary-expression before ‘.’ token

So to be clear, what is the difference between saying:

if (day == Days.Saturday) // Causes compilation error

and

if (day == Saturday)

?

What do these two actually refer to, in that one is OK and one causes a compilation error?

This code is wrong:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday}; Days day = Days.Saturday; if (day == Days.Saturday)

Because Days is not a scope, nor object. It is a type. And Types themselves don’t have members. What you wrote is the equivalent to std::string.clear. std::string is a type, so you can’t use . on it. You use . on an instance of a class.

Unfortunately, enums are magical and so the analogy stops there. Because with a class, you can do std::string::clear to get a pointer to the member function, but in C++03, Days::Sunday is invalid. (Which is sad). This is because C++ is (somewhat) backwards compatable with C, and C had no namespaces, so enumerations had to be in the global namespace. So the syntax is simply:

enum Days {Saturday, Sunday, Tuesday, Wednesday, Thursday, Friday}; Days day = Saturday; if (day == Saturday)

Fortunately, Mike Seymour observes that this has been addressed in C++11. Change enum to enum class and it gets its own scope; so Days::Sunday is not only valid, but is the only way to access Sunday. Happy days!