Implicit Conversions in C++

Sometimes a program needs a fixed set of named choices, such as the colors it understands, and it is convenient to use each choice as a plain name rather than a qualified one. C++ enumerations provide that tool. This article starts from a short program that uses one, and then works backward from what the program does to the rules that explain it.

Read these two lines once without running anything. Notice that green is written with no enum name in front of it, and that the result is stored in an ordinary int. Keep in mind what col ends up holding, because the next step asks you to commit to an answer before the explanation arrives.

A plain enum is created by writing the ordinary enum keyword, followed by a name and a braced list of enumerators. The source describes it through a simple change to a related form. If you do not want to explicitly qualify enumerator names, and you want enumerator values to behave as ints without an explicit conversion, you remove the class from enum class. What remains is a plain enum. The plain form therefore trades explicit qualification and explicit conversion for convenience.

The two defining properties of a plain enum can be read as a pair of choices. The first is whether enumerator names must be explicitly qualified. The second is whether enumerator values convert to integers without an explicit conversion. A plain enum chooses the looser setting on both. A scoped enum class chooses the stricter setting on both.

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.

This placement is what makes a plain enum convenient to read. A name like green can be written directly in the code that uses it. The same placement also means the enumerator names share the surrounding scope with everything else declared there. This is part of why the source calls plain enums less well behaved than their scoped counterparts.

The integer a plain enumerator converts to is determined by its position in the list. By default, the 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.

Once you can do this count reliably, you can predict the value of any enumerator in a short plain enum without running the code. The count depends only on list order, not on the spelling of the names.

Older and existing C++ code often contains plain enums, because the source notes they have been part of C++ and C since the earliest days of both languages and remain common in current code. Recognizing their two properties will help you read that code even when you would choose a scoped form for new work.

Many learners reading C++ for the first time notice that a Vector can be created from a single integer. If Vector v1(7) produces a vector holding 7 elements, it seems natural to think that the number 7 is simply turned into a Vector wherever a Vector is expected. Under that belief, Vector v2 = 7; should work just as well. The source material makes a precise claim against that belief: there is no implicit conversion from int to Vector.

The key distinction is between two operations. Creating a Vector from the number 7 by calling a constructor is a direct, explicit action written in the code. Letting the compiler silently replace a 7 with a Vector at an assignment is a different operation, and the source says that operation is not available for this class. Being able to construct an object directly does not mean the compiler will convert values of that type implicitly.