C++ Enums

Another common data requirement we will soon run in to is a desire to have a property be one of a limited set of values.

We've seen booleans for capturing one of two states - true or false, but what if we want a property to be one of a number of possibilities?

We could imagine a need to store a character's faction, for example, with possible values being "Human", "Elf", and "Undead"

This is where the enum comes in:

1enum class Faction {
2   Human,
3   Elf,
4   Undead
5}
6

Variables that store one of these values will have a type of Faction, and we can access the options using the scope resolution operator ::. This is shown in the below examples:

1Faction PlayerFaction { Faction::Human };
2

1bool isElf(Faction SelectedFaction) {
2  return SelectedFaction == Faction::Elf;
3}
4

1class Vampire {
2public:
3  Faction GetFaction() { return Faction };
4private:
5  Faction Faction { Faction::Undead }
6}
7
8Vampire Enemy;
9Faction EnemyFaction { Enemy.GetFaction() };
10

1enum class Hostility { Friendly, Neutral, Hostile };
2
3class Character {
4  // ?
5};
6

using Statements with Enums

In some files, we may want to use the same enum over and over again, and the constant qualification of MyEnumName:: would make our code excessively verbose.

We can solve this problem in the same we we tacked the equivalent issue with namespaces - by adding a using statement.

This can take our code from something like this:

1enum class Faction { Human, Elf, Undead };
2
3Faction MyFaction { Faction::Human };
4

To this:

1enum class Faction { Human, Elf, Undead };
2
3using enum Faction;
4
5Faction MyFaction { Human };
6

Note, using enum is a recent addition to the language, included as part of the C++ 20 spec that was published in 2021. It may not yet be supported by all compilers.

1enum class Hostility { Friendly, Neutral, Hostile };
2
3// ?
4
5class Character {
6  Hostility Hostility { Friendly };
7};
8

Advantages of Enums

We could have captured these multiple-choice variables as some other type - for example, integers or strings.

But, if we use integers, our code becomes quite difficult to follow, as we have to remember what the numbers mean. For example, is 3 an elf or a dwarf?

Strings like "dwarf" solve the readability problem. However, they consume more memory and network resources than an int, and they're also slower to compare.

Enums combine the performance of integers with the readability of strings. Additionally, they have even more advantages:

• The compiler will only permit valid values - there's no risk we introduce a bug by mistyping a string, or using a number that doesn't correspond to any value.
• Because an enum defines what the possible options are, our tools can be helpful. For example, our code editor will generally provide auto-complete support when we're working with enums.