Wie kann ich den Wert einer Enum-Klasse in C++ ausgeben 11

Question

Wie kann ich den Wert einer enum class in C++ 11 ausgeben? In C++ 03 ist es wie folgt aus:

#include <iostream> 

using namespace std; 

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

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

in C++ 0x dieser Code nicht

#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]' 

bei Ideone.com

Answer 1

Im Gegensatz zu einer unscoped Aufzählung kompiliert nicht kompiliert, ein scoped Aufzählung nicht implizit umwandelbar zu seinem ganzzahligen Wert. Sie müssen explizit es mit einer Umwandlung in eine ganze Zahl konvertieren:

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

Möglicherweise möchten Sie die Logik in eine Funktionsvorlage kapseln:

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

als gebraucht:

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

(Ich darf noch nicht kommentieren.) Ich würde die folgenden Verbesserungen vorschlagen die bereits große Antwort von 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); 
} 

mit

• constexpr: Erlaubt mir einen ENUM Mitglied Wert als Kompilierung-Array-Größe zu verwenden
• static_assert + is_enum: zu 'sichern' kompilieren -Zeit, dass die Funktion etw. nur mit Aufzählungen, wie
vorgeschlagen

Durch die Art, wie ich mich frage: Warum sollte ich jemals enum class verwenden, wenn ich möchte Zahlenwerte an meine Enum-Mitglieder zuweisen ?! Bedenkt den Umstellungsaufwand.

Vielleicht würde ich dann auf gewöhnliche enum gehen zurück, als ich hier vorgeschlagen: How to use enums as flags in C++?

---

Noch einen anderen (besser) Geschmack davon ohne static_assert, basierend auf einem Vorschlag von @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 ist möglich, Ihr zweites Beispiel (dh das, das eine bereichsspezifische Enumeration verwendet) zu verwenden, um die gleiche Syntax wie nicht aufgezeichnete Enums zu verwenden. Darüber hinaus ist die Lösung generisch und wird für alle Bereichsaufzählungen funktionieren, im Gegensatz zum Schreiben von Code für jede Bereichsaufzählung (wie in answer von @ForEveR gezeigt).

Die Lösung besteht darin, eine generische operator<<-Funktion zu schreiben, die für beliebige Bereichsaufzählungen funktioniert. Die Lösung verwendet SFINAE über std::enable_if und ist wie folgt.

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