webentwicklung-frage-antwort-db.com.de

Kann eine Enum-Klasse in den zugrunde liegenden Typ konvertiert werden?

Gibt es eine Möglichkeit, ein enum class-Feld in den zugrunde liegenden Typ zu konvertieren? Ich dachte, das wäre automatisch, aber anscheinend nicht.

enum class my_fields : unsigned { field = 1 };

unsigned a = my_fields::field;

Diese Aufgabe wird von GCC abgelehnt. error: cannot convert 'my_fields' to 'unsigned int' in assignment.

96

Ich denke, Sie können std ::lying_type verwenden, um den zugrunde liegenden Typ zu kennen, und dann cast verwenden:

#include <type_traits> //for std::underlying_type

typedef std::underlying_type<my_fields>::type utype;

utype a = static_cast<utype>(my_fields::field);

Dabei müssen Sie nicht den zugrunde liegenden Typ angenommen angeben, oder Sie müssen ihn nicht in der Definition des enum class wie enum class my_fields : int { .... } oder so angeben.

Sie können sogar eine generic convert-Funktion schreiben, die anyenum class in den zugrunde liegenden integral-Typ konvertieren kann:

template<typename E>
constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type 
{
   return static_cast<typename std::underlying_type<E>::type>(e);
}

dann benutze es:

auto value = to_integral(my_fields::field);

auto redValue = to_integral(Color::Red);//where Color is an enum class!

Und da die Funktion als constexpr deklariert ist, können Sie sie verwenden, wenn ein konstanter Ausdruck erforderlich ist:

int a[to_integral(my_fields::field)]; //declaring an array

std::array<int, to_integral(my_fields::field)> b; //better!

Hoffentlich hilft das.

161
Nawaz

Sie können es nicht implizit konvertieren, aber eine explizite Umwandlung ist möglich:

enum class my_fields : unsigned { field = 1 };

// ...

unsigned x = my_fields::field; // ERROR!
unsigned x = static_cast<unsigned>(my_fields::field); // OK

Beachten Sie auch die Tatsache, dass das Semikolon after die geschlossene geschweifte Klammer in der Definition Ihres Enums sein sollte, nicht vorher.

38
Andy Prowl

Die folgende Funktion underlying_cast finde ich nützlich, wenn Enumerationswerte korrekt serialisiert werden müssen.

namespace util
{

namespace detail
{
    template <typename E>
    using UnderlyingType = typename std::underlying_type<E>::type;

    template <typename E>
    using EnumTypesOnly = typename std::enable_if<std::is_enum<E>::value, E>::type;

}   // namespace util.detail


template <typename E, typename = detail::EnumTypesOnly<E>>
constexpr detail::UnderlyingType<E> underlying_cast(E e) {
    return static_cast<detail::UnderlyingType<E>>(e);
}

}   // namespace util

enum SomeEnum : uint16_t { A, B };

void write(SomeEnum /*e*/) {
    std::cout << "SomeEnum!\n";
}

void write(uint16_t /*v*/) {
    std::cout << "uint16_t!\n";
}

int main(int argc, char* argv[]) {
    SomeEnum e = B;
    write(util::underlying_cast(e));
    return 0;
}
0
James