In C++, an enumeration, commonly known as enum, is a user-defined type that allows you to define a set of named integral constants. These constants, also known as enumerators, provide a convenient way to represent a fixed set of values within a program. In this article, we will explore the concept of enumerations in C++ and understand their syntax, usage, and various features.

Syntax of Enumerations

The syntax for defining an enumeration in C++ follows a specific pattern. Let’s take a look at the basic syntax:

enum enum-name : underlying-type
   // ...

In the above syntax:

  • enum-name is the name given to the enumeration, which will be used to refer to the type.
  • underlying-type is the integral type that will be used to represent the enumerators. It can be any integral type, such as int, char, or short.
  • enumerator1, enumerator2, and so on, represent the named constants or enumerators within the enumeration.

Usage of Enumerations

Enumerations provide a convenient way to define a set of related constants. Let’s consider an example where we need to represent the days of the week:

enum Days

In the above code, we have defined an enumeration Days with the names of the days of the week as its enumerators. Now, we can use these enumerators in our program to represent specific days. For example:

Days today = Tuesday;

Here, we have assigned the enumerator Tuesday to the variable today.

Scoped Enumerations

In C++11, a new type of enumeration called a scoped enumeration, or enum class, was introduced. Scoped enumerations provide better encapsulation and prevent naming conflicts by introducing a scope for the enumerators. The syntax for defining a scoped enumeration is slightly different:

enum class enum-name : underlying-type
   // ...

In the above syntax, the class keyword indicates that we are defining a scoped enumeration.

Benefits of Scoped Enumerations

Scoped enumerations offer several benefits over traditional unscoped enumerations. They provide better type safety, as the enumerators are not implicitly convertible to integers. This helps prevent accidental assignments and enhances code clarity. Additionally, scoped enumerations have their enumerators enclosed within their scope, reducing the chances of naming conflicts.

Enumerator Scope

One crucial difference between scoped and unscoped enumerations is how the enumerator names are accessed. In unscoped enumerations, the enumerator names are visible throughout the scope in which the enumeration is declared. However, in scoped enumerations, the enumerator names must be qualified by the enumeration name. Consider the following example:

enum class Colors

void printColor(Colors color)
   if (color == Colors::Red)
       // ...

In the above code, we need to qualify the enumerator Red with the enumeration name Colors when comparing it within the printColor function.

Casting and Conversions

Casting plays an important role when working with enumerations. Unscoped enum constants can be implicitly converted to integers, but the reverse is not true. Scoped enumerations, on the other hand, require explicit casting to convert between enumerators and integers. Consider the following example:

enum Numbers

enum class Letters

Numbers num = One;
int numValue = static_cast<int>(num); // Casting to int

Letters letter = Letters::B;
int letterValue = static_cast<int>(letter); // Casting to int

In the above code, we demonstrate how to cast both unscoped and scoped enumerators to integers using the static_cast operator.


In summary, enumerations in C++ provide a powerful way to define named integral constants. They allow you to create a set of related values, making your code more readable and maintainable. Whether you choose unscoped enumerations or the newer scoped enumerations, understanding their syntax, usage, and features will greatly benefit your C++ programming skills.

By mastering the concept of enumerations, you can enhance your ability to represent and manipulate sets of related values within your C++ programs. So go ahead, leverage the power of enumerations, and write more expressive and concise code!


What is the purpose of enum in C++?

The purpose of enums in C++ is to provide a way to define a set of named integral constants. Enums allow programmers to represent a fixed set of values with more readable and maintainable code. They make the code easier to understand by providing meaningful names to represent specific values instead of using raw integers.

How do you assign values to enum constants in C++?

By default, if you don’t assign values to enum constants, they are automatically assigned increasing integral values starting from 0. However, you can explicitly assign values to enum constants. For example:

enum Colors
   Red = 1,
   Green = 2,
   Blue = 4

n the above code, Red is assigned the value 1, Green is assigned 2, and Blue is assigned 4. Subsequent constants without explicit values will be assigned the previous constant’s value plus one.

What is the difference between a scoped enum and an unscoped enum?

The main difference between a scoped enum and an unscoped enum is how their enumerators are accessed. In an unscoped enum, the enumerators are visible throughout the scope in which the enum is declared. In contrast, a scoped enum introduces a scope for its enumerators, and the enumerator names must be qualified by the enumeration name to access them.

Can enum constants be used as flags in C++?

Yes, enum constants can be used as flags in C++. This technique is known as “bit flags” or “flag enums.” By assigning different values to the enum constants using powers of 2, you can combine multiple enum values using bitwise operators such as OR (|) and AND (&). This allows you to represent combinations of options or states. Flag enums provide a concise and expressive way to work with multiple boolean conditions or options.

FAQ: What is the advantage of using enums over constants in C++?

Using enums over constants in C++ provides several advantages. Enums improve code readability by giving meaningful names to represent specific values, making the code more self-explanatory. They also help catch errors at compile-time by enforcing type safety. Enums make the code more maintainable because changes to the set of values only require modifying the enum definition instead of searching and replacing raw constants throughout the code. Additionally, enums provide better debugging support, as the symbolic names of enum constants can be displayed during runtime.

Are enum types strongly typed in C++?

Yes, enum types in C++ are strongly typed. This means that enumerators of different enum types are treated as different types, even if they have the same underlying integral type. Strong typing helps prevent accidental assignment or comparison between different enum types, improving type safety and reducing potential programming errors.

Opt out or Contact us anytime. See our Privacy Notice

Follow us on Reddit for more insights and updates.

Comments (0)

Welcome to A*Help comments!

We’re all about debate and discussion at A*Help.

We value the diverse opinions of users, so you may find points of view that you don’t agree with. And that’s cool. However, there are certain things we’re not OK with: attempts to manipulate our data in any way, for example, or the posting of discriminative, offensive, hateful, or disparaging material.

Your email address will not be published. Required fields are marked *


Register | Lost your password?