Mfcttrf

I'm converting unscoped enumerations to scoped enumerations, and have run across a puzzle.

Stroustroup, C++ Programming Language, 4th edition, Section 8.4.1, documents that scoped enum classes are not implicitly converted to integral types, and provides code for operators | and & as an example of how to use static_cast to work around that.

Shouldn't the following initialization using the | operator on previously defined enum values be illegal?

enum class FileCopy CurrentHDU ;

int main()

 std::cout << static_cast<int>( FileCopy::AllHDUs) << "n";

I've tested this on Wandbox using both clang & gcc HEAD with --pedantic-errors, and it compiles and returns the expected output, 7. That's not to say it's legal, just that it seems to be accepted by the compilers.

Is this explicitly documented behavior? I've been unable to parse the documentation in a way that describes this behavior.

[dcl.enum]/5:

... If the underlying type is fixed, the type of each enumerator prior to the closing brace is the underlying type ...

That is, each enumerator has type int until the closing brace is encountered. After that point, the enumerators have type FileCopy and you would not be able to bitwise-OR them together like this anymore.

According to the C++17 Standard (8.5.13 Bitwise inclusive OR operator)

1 The usual arithmetic conversions (8.3) are performed; the result is
the bitwise inclusive OR function of its operands. The operator
applies only to integral or unscoped enumeration operands.

And (10.2 Enumeration declarations)

5. ... For a scoped enumeration type, the underlying type is int if it is not
   explicitly specified. In both of these cases, the underlying
   type is said to be fixed. Following the closing brace of an
   enum-specifier, each enumerator has the type of its enumeration. If
   the underlying type is fixed, the type of each enumerator prior to the
   closing brace is the underlying type and the constant-expression in
   the enumerator-definition shall be a converted constant expression of
   the underlying type

So this is explicitly documented behavior.

As long as the value you assign fits in the underlying type of the (possibly scoped) enum, then it's a valid value of the enumeration. It does not have to be one of the explicitly named enum values.

See http://eel.is/c++draft/dcl.enum#8 for all the technical standards details, but the key point is "... It is possible to define an enumeration that has values not defined by any of its enumerators...".