¿Cómo puedo generar el valor de una clase enum en C++ 11

Question

¿Cómo puedo generar el valor de enum class en C++ 11? En C++ 03 es la siguiente:

#include <iostream> 

using namespace std; 

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

int main() { 
    A a = A::c; 
    cout << a << endl; 
} 

en C++ 0x este código no compila

#include <iostream> 

using namespace std; 

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

int main() { 
    A a = A::c; 
    cout << a << endl; 
} 


prog.cpp:13:11: error: cannot bind 'std::ostream' lvalue to 'std::basic_ostream<char>&&' 
/usr/lib/gcc/i686-pc-linux-gnu/4.5.1/../../../../include/c++/4.5.1/ostream:579:5: error: initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char, _Traits = std::char_traits<char>, _Tp = A]' 

compilan en Ideone.com

Answer 1

A diferencia de una enumeración sin ámbito, una enumeración con ámbito es no implícitamente convertible a su valor entero. Es necesario que explícitamente convertirlo en un entero usando un reparto:

std::cout << static_cast<std::underlying_type<A>::type>(a) << std::endl; 

es posible que desee encapsular la lógica en una plantilla de función:

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); 
} 

utilizado como:

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

Answer 2

#include <iostream> 
#include <type_traits> 

using namespace std; 

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; 
    cout << a << endl; 
} 

Answer 3

(No tengo permiso para comentar aún) Sugeriría las siguientes mejoras para la ya gran respuesta de James McNellis:

template <typename Enumeration> 
constexpr auto as_integer(Enumeration const value) 
    -> typename std::underlying_type<Enumeration>::type 
{ 
    static_assert(std::is_enum<Enumeration>::value, "parameter is not of type enum or enum class"); 
    return static_cast<typename std::underlying_type<Enumeration>::type>(value); 
} 

con

• constexpr: permitir que utilice un valor de miembro de la enumeración como en tiempo de compilación tamaño de la matriz
• static_assert + is_enum: la de garantizar compilar -tiempo que la función hace algo con enumeraciones solamente, como se sugiere

Por cierto que estoy preguntando a mí mismo: ¿Por qué debería utilizar nunca enum class cuando quisiera asignar valores numéricos a los miembros de mi enumeración ?! Teniendo en cuenta el esfuerzo de conversión.

Tal vez me permitiría volver a enum ordinaria como he sugerido aquí: How to use enums as flags in C++?

---

Sin embargo, otro (mejor) el sabor de la misma sin static_assert, basado en una sugerencia de @TobySpeight:

template <typename Enumeration> 
constexpr std::enable_if_t<std::is_enum<Enumeration>::value, 
std::underlying_type_t<Enumeration>> as_number(const Enumeration value) 
{ 
    return static_cast<std::underlying_type_t<Enumeration>>(value); 
} 

Answer 4

Es posible obtener su segundo ejemplo (es decir, el que usa una enumeración de ámbito) para trabajar con la misma sintaxis que las enumeraciones sin ámbito. Además, la solución es genérica y funcionará para todas las enumeraciones con ámbito, en comparación con el código de escritura para cada enum con ámbito (como se muestra en el answer proporcionado por @ForEveR).

La solución es escribir una función genérica operator<< que funcionará para cualquier enum de ámbito. La solución emplea SFINAE a través de std::enable_if y es la siguiente.

#include <iostream> 
#include <type_traits> 

// Scoped enum 
enum class Color 
{ 
    Red, 
    Green, 
    Blue 
}; 

// Unscoped enum 
enum Orientation 
{ 
    Horizontal, 
    Vertical 
}; 

// Another scoped enum 
enum class ExecStatus 
{ 
    Idle, 
    Started, 
    Running 
}; 

template<typename T> 
std::ostream& operator<<(typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e) 
{ 
    return stream << static_cast<typename std::underlying_type<T>::type>(e); 
} 

int main() 
{ 
    std::cout << Color::Blue << "\n"; 
    std::cout << Vertical << "\n"; 
    std::cout << ExecStatus::Running << "\n"; 
    return 0; 
}