Enumerator Scope and Qualification

Sometimes a program needs a fixed set of named choices, such as the colors it understands, and it is convenient for each choice to be usable as a plain name rather than a qualified one. C++ enumerations provide that tool. Before any rules are introduced, read the two lines below once and do not run them.

The rest of this article explains the two rules that produce that result: where the names of a plain enum are visible, and how its integer values are counted. Keep the answer you chose in mind, because the explanation will show whether your prediction matched the rules.

A plain enum is created by writing the enum keyword, then a name, then a braced list of enumerators. The plain form is obtained from the scoped form by removing the word class from enum class. That single change trades explicit qualification and conversion for convenience. The scoped form requires you to write the enum name before an enumerator, while the plain form does not. The plain form also converts an enumerator to an integer automatically, while the scoped form does not.

So a plain enum makes two choices, and both are the looser setting. First, enumerator names do not have to be qualified. Second, enumerator values behave as integers without an explicit conversion. Those two properties are what the word plain refers to in this article.

The enumerators of a plain enum are placed in the same scope as the enum's own name. In the Color example, the name Color and the names red, green, and blue all belong to the scope where the enum is declared. No extra qualifier is needed to reach an enumerator from that scope. A name such as green can be written directly in the code that uses it.

The same placement that makes plain enums convenient also has a cost. Enumerator names share the surrounding scope with everything else declared there. This is part of why plain enums are described as less well behaved than their scoped counterparts. A name introduced by an enum can collide with a variable, a function, or another enumerator that already occupies the same scope.

The integer a plain enumerator converts to is determined by its position in the list. By default, integer values start at 0, and each additional enumerator has a value one greater than the enumerator before it. The first enumerator in the list has value 0, the next has value 1, and so on through the list in order.

An enumerator can also be given an explicit value. When it is, the enumerators after it continue counting from that value rather than from the default. The following generated example shows that behavior.

Now trace the state of the program from the opening example. Before the assignment, col has no value that you can rely on. The assignment reads green, which is a plain enumerator, and the implicit conversion turns it into its integer value. The variable then holds that integer.

No cast appears anywhere in the assignment. The conversion happens because an enumerator appearing where an integer is needed is converted to its integer value. The stored value is the position-based value from the counting rule, so the only thing you need to know to predict col is the position of green in the list.

Comparing the two forms makes the design choice clear. The plain form gives you convenience, and the scoped form gives you explicit qualification and no implicit conversion to int.

Plain enums remain common in current code, and they have been part of C++ and C since the earliest days of both languages. When you read existing C++ code, you should expect to meet them, so understanding their two properties is practically useful even when you would choose the scoped form for new code.