typechecking provided on enum

Question

I would expect the following code snippet to complain about trying to assign something other that 0,1,2 to a Color variable. But the following does compile and I get the output

Printing:3

3

Can anybody explain why? Is enum not meant to be a true user-defined type? Thanks.

enum Color { blue=0,green=1,yellow=2};

void print_color(Color x);

int main(){
    Color x=Color(3);

    print_color(x);
    std::cout << x << std::endl;

    return 0;
}

void print_color(Color x)
{
    std::cout << "Printing:" << x << std::endl;
}

Answer 1

Since you manually cast the 3 to Color, the compiler will allow you to do that. If you tried to initialize the variable x with a plain 3 without a cast, you would get a diagnostic.

Note that the range of values an enumeration can store is not limited by the enumerators it contains. It's the range of values of the smallest bitfield that can store all enumerator values of the enumeration. That is, the range of your enumeration type is 0..3:

00
01
10
11

The value 3 is thus still in range, and so the code is valid. Had you cast a 4, then the resulting value would be left unspecified by the C++ Standard.

In practice, the implementation has to chose an underlying integer type for the enumeration. The smallest type it can choose is char, but which is still able to at least store values ranging up to 127. But as mentioned, the compiler is not required to convert a 4 to a value of 4, because it's outside the range of your enumeration.

---

I figure i should post some explanation on the difference of "underlying type" and "range of enumeration values". The range of values for any type is the smallest and largest value of that type. The underlying type of an enumeration must be able to store the value of any enumerator (of course) - and two enumerations that have the same underlying type are layout compatible (this allows some flexibility in case a type mismatch occurs).

So while the underlying type is meant to fix the object representation (alignment and size), the values of the enumeration is defined as follows in 7.2/6

For an enumeration where e_min is the smallest enumerator and e_max is the largest, the values of the enumeration are the values of the underlying type in the range b_min to b_max, where b_min and b_max are, respectively, the smallest and largest values of the smallest bit-field that can store e_min and e_max . It is possible to define an enumeration that has values not defined by any of its enumerators.

[Footnote: On a two’s-complement machine, b_max is the smallest value greater than or equal to max (abs(e_min) − 1 ,abs(e_max)) of the form 2^M−1; b_min is zero if e_min is non-negative and −(b_min+1) otherwise.]

Answer 2

Both the C and the C++ standards are kind of confusing on the subject of enums. Both insist that enums are "distinct types" but then both treat them as the underlying integral type. C++ even refers to an italic term "underlying type" which is only sort-of defined when introducing wchar_t.

In summary, wchar_t and enum types are "distinct" but simply mapped to an underlying integral type chosen by the implementation, and this is no doubt due to the need to be compatible with historical enum which was definitely just an int.

Modern compilers typically have options to add more type-like behavior to enums, turning on warnings and errors for various misuses. These can't be a default because they elect non-conforming behavior.

Answer 3

Color(3) is a cast, with the same semantic as (Color)3, it isn't a constructor. Note that you can also use static_cast<Color>(3) for the same conversion but you can't use Color x(3).

Answer 4

Enum in C++ is more of a set of named integer constants than a true type, from compile-time checking point of view. However, the C++ standard has this to say [dcl.enum]:

9 An expression of arithmetic or enumeration type can be converted to an enumeration type explicitly. The value is unchanged if it is in the range of enumeration values of the enumeration type; otherwise the resulting enumeration value is unspecified.

"Unspecified" is slightly better than the usual "undefined behavior".