Outputting Values of Enum Classes in C++11: From Implicit to Explicit Handling

Background and Challenges of Outputting Enum Class Values in C++11

In C++03 and earlier versions, traditional enums (unscoped enumerations) allow implicit conversion to integer types, enabling direct use with output stream operators. For example, the following code compiles and runs successfully:

#include <iostream>

enum A {
  a = 1,
  b = 69,
  c = 666
};

int main() {
  A a = A::c;
  std::cout << a << std::endl; // Outputs 666
}

However, the introduction of enum classes (scoped enumerations, also known as strong enums) in C++11 changed this behavior. Defined using the enum class keyword, enum classes provide better type safety and scope restrictions. But this also introduces new challenges: enum classes no longer support implicit conversion to their underlying integer types. Attempting to compile the following code results in a compiler error:

#include <iostream>

enum class A {
  a = 1,
  b = 69,
  c = 666
};

int main() {
  A a = A::c;
  std::cout << a << std::endl; // Compilation error
}

The error typically indicates an inability to bind the enum type to the output stream, as the << operator for std::cout is not overloaded for enum classes. This design decision aims to prevent accidental type conversions, enhancing code robustness, but requires developers to handle conversions explicitly.

Core Solution: Explicit Type Conversion

To output the value of an enum class, explicit type conversion is necessary. C++11 provides tools like static_cast and std::underlying_type for this purpose. std::underlying_type is a type trait that retrieves the underlying integer type of an enum (e.g., int, unsigned int). The basic usage is as follows:

#include <iostream>
#include <type_traits>

enum class A {
  a = 1,
  b = 69,
  c = 666
};

int main() {
  A a = A::c;
  std::cout << static_cast<std::underlying_type<A>::type>(a) << std::endl; // Outputs 666
}

This method is direct and effective, but the code can become verbose, especially with repeated use. To improve readability and reusability, it can be encapsulated into a function template.

Function Template Encapsulation: Enhancing Code Maintainability

By defining a function template, the type conversion logic can be abstracted, making the code more concise. Here is an example implementation:

template <typename Enumeration>
auto as_integer(Enumeration const value)
    -> typename std::underlying_type<Enumeration>::type
{
    return static_cast<typename std::underlying_type<Enumeration>::type>(value);
}

Using C++11's trailing return type syntax, this template function automatically deduces and returns the underlying integer type of the enum. In code, it can be called simply as:

std::cout << as_integer(a) << std::endl;

This approach not only reduces code duplication but also enhances type safety, as the template ensures conversion is only applied to enum types.

Operator Overloading: Extending Output Stream Functionality

Another common solution is to overload the output stream operator << for the enum class. This allows direct use of the syntax std::cout << a, similar to traditional enums. An implementation is shown below:

#include <iostream>
#include <type_traits>

enum class A {
  a = 1,
  b = 69,
  c = 666
};

std::ostream& operator << (std::ostream& os, const A& obj)
{
   os << static_cast<std::underlying_type<A>::type>(obj);
   return os;
}

int main() {
  A a = A::c;
  std::cout << a << std::endl; // Outputs 666
}

Overloading the operator provides a more natural interface, but care must be taken regarding scope and potential naming conflicts. In real-world projects, it is advisable to define the overload in the same namespace as the enum to leverage argument-dependent lookup (ADL).

Type Safety and Best Practices

The primary goal of introducing enum classes in C++11 is to enhance type safety. By prohibiting implicit conversions, the compiler can catch more errors at compile time, such as unintended integer comparisons or assignments. When handling enum class output, the following best practices should be observed:

• Prefer explicit conversions, like static_cast, to clarify intent.
• Consider using function templates (e.g., as_integer) to encapsulate conversion logic, improving code reusability.
• In scenarios requiring frequent output, operator overloading can be used, but it should be designed carefully to avoid misuse.
• Utilize std::underlying_type to ensure generic and correct conversions, especially when the underlying type of the enum might change.

In summary, C++11 enum classes trade some convenience for stronger type safety. Developers must adapt by adopting explicit handling methods to output enum values, thereby writing more robust and maintainable code.