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

Wie kann ich den Wert von a enum classin C ++ 11 ausgeben ? In C ++ 03 ist es so:

#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 wird dieser Code nicht kompiliert

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

zusammengestellt bei Ideone.com

Im Gegensatz zu einer Aufzählung ohne Gültigkeitsbereich kann eine Aufzählung mit Gültigkeitsbereich nicht implizit in ihren ganzzahligen Wert konvertiert werden. Sie müssen es mithilfe einer Umwandlung explizit in eine Ganzzahl konvertieren:

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

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

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

benutzt als:

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

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

Es ist möglich, dass Ihr zweites Beispiel (dh das mit einer Aufzählung mit Gültigkeitsbereich) mit derselben Syntax wie Aufzählungen ohne Gültigkeitsbereich funktioniert. Darüber hinaus ist die Lösung generisch und funktioniert für alle Enums mit Gültigkeitsbereich, während Code für jede Enumeration mit Gültigkeitsbereich geschrieben wird (wie in der Antwort von @ForEveR gezeigt) ).

Die Lösung besteht darin, eine generische operator<<Funktion zu schreiben, die für jede Enumeration mit Gültigkeitsbereich funktioniert. Die Lösung verwendet SFINAE über std::enable_ifund 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;
}

(Ich darf noch keinen Kommentar abgeben.) Ich würde die folgenden Verbesserungen der bereits großartigen Antwort von James McNellis vorschlagen:

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-Member-Wert als Array-Größe zur Kompilierungszeit zu verwenden
• static_assert+ is_enum: um die Kompilierungszeit sicherzustellen, dass die Funktion etw. nur mit Aufzählungen, wie vorgeschlagen

Übrigens frage ich mich: Warum sollte ich jemals verwenden, enum classwenn ich meinen Enum-Mitgliedern Zahlenwerte zuweisen möchte?! Berücksichtigung des Konvertierungsaufwands.

Vielleicht würde ich dann wieder zum Normalen zurückkehren enum Normalen wie ich hier vorgeschlagen habe: Wie verwende ich Enums als Flags in C ++?

Noch eine (bessere) Variante 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);
}

Einfacher schreiben,

enum class Color
{
    Red = 1,
    Green = 11,
    Blue = 111
};

int value = static_cast<int>(Color::Blue); // 111

Folgendes hat in C ++ 11 für mich funktioniert:

template <typename Enum>
constexpr typename std::enable_if<std::is_enum<Enum>::value,
                                  typename std::underlying_type<Enum>::type>::type
to_integral(Enum const& value) {
    return static_cast<typename std::underlying_type<Enum>::type>(value);
}

Sie könnten so etwas tun:

//outside of main
namespace A
{
    enum A
    {
        a = 0,
        b = 69,
        c = 666
    };
};

//in main:

A::A a = A::c;
std::cout << a << std::endl;