Chapter 6
Enumerations
Cippi counts from one to five.
Enumerations are used to define sets of integer values and also a type for such sets of values. Although this section has eight rules about enums, there is a crucial rule. Prefer scoped enumerations to classic enumerations. Scoped enumerations are also called strongly typed enums or enum classes.
General Rules
Classical enumerations (before C++11) have many drawbacks. Let me explicitly compare plain (unscoped) enumerations and scoped enumerations because the difference is not explicitly mentioned in the C++ Core Guidelines.
Here is a classical enumeration:
enum Color {
red,
blue,
green
};
What are the drawbacks of classical enumerations? The enumerators
Have no scope.
Implicitly convert
int.Pollute the global namespace.
Have an unknown type. The type has to be big enough to hold the enumerators.
By using the keyword class or struct, the enumeration becomes a scoped enumeration (class enum):
enum class ColorScoped {
red,
blue,
green
};
Now you have to use the scope operator (::) to access the enumerators: ColorScoped::red. ColorScoped::red does not implicitly convert to int and, therefore, does not pollute the global namespace. This is the reason they are often called strongly typed.
Additionally, the underlying type is by default int, but you can choose a different integral type.
Now that the background information has been provided, let’s dive directly into the most important rules.
Macros don’t respect scope and have no type. This means you can override a previously set macro that specifies a color.
// webcolors.h #define RED 0xFF0000 // productinfo.h #define RED 0 int webcolor = RED; // should be 0xFF0000
With ColorScoped, this would not have happened because you have to use the scope operator: ColorScoped webcolor = ColorScoped::red;.
Use enumerations to represent sets of related named constants |
This rule is obvious because enumerators create a set of integers, which is a named type.
enum class Day {
Mon,
Tue,
Wed,
Thu,
Fri,
Sat,
Sun
};
The enumerators of a scoped enumerator (enum class) do not automatically convert to int. You have to access them with the scope operator.
// scopedEnum.cpp
#include <iostream>
enum class ColorScoped {
red,
blue,
green
};
void useMe(ColorScoped color) {
switch(color) {
case ColorScoped::red:
std::cout << "ColorScoped::red" << '\n';
break;
case ColorScoped::blue:
std::cout << "ColorScoped::blue" << '\n';
break;
case ColorScoped::green:
std::cout << "ColorScoped::green" << '\n';
break;
}
}
int main() {
std::cout << static_cast<int>(ColorScoped::red) << '\n'; // 0
std::cout << static_cast<int>(ColorScoped::green) << '\n'; // 2
ColorScoped color{ColorScoped::red};
useMe(color); // ColorScoped::red
}
If you use ALL_CAPS for enumerators, you may get a conflict with macros because they are typically written in ALL_CAPS.
enum class ColorScoped{ RED };
#define RED 0xFF0000
Of course, this rule does not only apply to enumerators but to constants in general.
Not every compile-time constant should be an enum. C++ also lets you define compile-time constants as constexpr variables. Use enums only for sets of related constants (Enum.2).
// bad
enum { red = 0xFF0000, scale = 4, is_signed = 1 };
// good
constexpr int red = 0xFF0000;
constexpr short scale = 4;
constexpr bool is_signed = true;
Specify the underlying type of an enumeration only when necessary |
Since C++11, you can specify the underlying type of the enumeration and save memory. By default, the type of a scoped enum is int, and therefore, you can forward declare an enum.
// typeEnum.cpp
#include <iostream>
enum class Color1 {
red,
blue,
green
};
enum struct Color2: char {
red,
blue,
green
};
int main() {
std::cout << sizeof(Color1) << '\n'; // 4
std::cout << sizeof(Color2) << '\n'; // 1
}
By specifying the enumerator values, you may set a value twice. The following enumeration Col2 has this issue.
enum class Col1 { red, yellow, blue };
enum class Col2 { red = 1, yellow = 2, blue = 2 }; // typo
enum class Month { jan = 1, feb, mar,
apr, may, jun,
jul, aug, sep,
oct, nov, dec }; // 1 is conventional
Sccoped enumerations check the value of their underlying enumerators at compile time.
// enumChecksRange.cpp
enum struct Color: char {
red = 127,
blue,
green
};
int main() {
Color color{Color::green};
}
The compilation of the program fails because the enumerators are too big to fit into the underlying type (see Figure 6.1).
Figure 6.1 The enumerators are too big for the underlying type
With classical enumerators, the size of the underlying type would be just big enough.
Related rules
Chapter 8, Expressions and Statements, deepens the discussion to constexpr values.