Wie kann ich eine Enum-Klasse in einem booleschen Kontext verwenden?

Question

Ich habe einige generische Code, der mit Flags funktioniert mit C++ 11 enum class Typen angegeben. Bei einem Schritt möchte ich wissen, ob eines der Bits in der Flagge gesetzt ist. Derzeit verwende ich den Code:

if (flags != static_cast<E>(0)) // Works, but ugly. 

ich auch Benutzer zwingen könnte, einen bestimmten Namen für ein All-Null-Feld angeben, die besser lesbar ist, sondern erlegt meine Namenskonventionen für jedermann verwenden es:

if (flags != E::none) // Works, if you manually define none = 0. 

Doch diese beiden liest so schön wie die traditionelle:

if (flags) // Doesn't work with class enums. 

Ist es möglich, eine benutzerdefinierte Funktion angeben, eine Klasse enum in einem booleschen Kontext zu bewerten?

Answer 1

Ist es möglich, eine benutzerdefinierte Funktion anzugeben, um eine Klassenaufzählung in einem booleschen Kontext auszuwerten?

Ja, aber nicht automatisch. Das manuelle Aufrufen einer Funktion ist noch eleganter als die anderen dargestellten Alternativen.

Wählen Sie einfach einen schönen Funktionsnamen, z. B. any, und implementieren Sie ihn. Die Überladungsauflösung stellt sicher, dass Ihre Funktion mit allen anderen gut spielt.

bool any(E arg) 
    { return arg != E::none; } 

... 

if (any(flags)) { 
    ... 

Sieht gut genug für mich.

---

Update: wenn Sie dies mehrere Aufzählungstypen anwenden möchten, kann es als Templat werden:

template< typename enum_type > // Declare traits type 
struct enum_traits {}; // Don't need to declare all possible traits 

template<> 
struct enum_traits<E> { // Specify traits for "E" 
    static constexpr bool has_any = true; // Only need to specify true traits 
}; 

template< typename enum_type > // SFINAE makes function contingent on trait 
typename std::enable_if< enum_traits<enum_type>::has_any, 
    bool >::type 
any(enum_type e) 
    { return e != enum_type::none; } 

Ich habe mit dieser Art von Mechanismus für andere Dinge und begegnet nie Nebenwirkungen oder Probleme: v).

Sie könnten das Merkmal überspringen und die SFINAE-Bedingung auf etwas wie enum_type::none == enum_type::none setzen, um lediglich auf das Vorhandensein von none und den Gleichheitsoperator zu prüfen, aber das wäre weniger explizit und sicher.

Answer 2

Nein, nicht so. Konvertierungsoperatoren müssen Mitglieder sein, und Enums dürfen keine Mitglieder haben. Ich denke, das Beste, was Sie tun können, ist Vergleich mit none, oder, wenn es keinen none Enumerator gibt, wickeln Sie die static_cast in einer Funktion.

Answer 3

Wie @RMatin sagt. Aber man konnte überlasten operator!

bool operator!(E e) { 
    return e == static_cast<E>(0); 
} 

Damit Sie die !!e Idiom verwenden können

if(!!e) { 
    ... 
} 

Answer 4

Wenn Sie ein Flag-Feld haben (dh ein Bitfeld) Ich würde stark beraten Sie nicht enum class zu verwenden für Bitfelder.

Stark typisierte enums existieren, nun, stark typisiert. Es macht die Enumeratoren zu etwas mehr als nur benannten konstanten Ganzzahlen wie reguläre enums. Die Idee ist, dass, wenn Sie eine Variable eines enum class Typs haben, der Inhalt immer genau mit einem der Enumeratorwerte übereinstimmen sollte. Aus diesem Grund gibt es keine implizite Konvertierung von oder zu Integer-Typen.

Aber das ist nicht das, was Sie tun. Sie nehmen ein Bitfeld, das eine Zusammenstellung von Aufzählungswerten ist. Diese Zusammensetzung ist selbst keiner dieser Werte; Es ist eine Kombination von ihnen. Daher sind Sie liegen, wenn Sie sagen, dass Sie die enum class Art nehmen; Sie nehmen wirklich nur eine Ganzzahl ohne Vorzeichen, die könnte einer der enum class Enumeratoren sein.

Zum Beispiel:

enum class Foo 
{ 
    First = 0x01, 
    Second = 0x02, 
    Third = 0x04, 
}; 

Foo val = Foo::First | Foo::Second; 

val in diesem Fall enthält keine First, Second oder Third. Sie haben verloren starke Eingabe, weil es keinen der Typen enthält.

enum class Werte können nicht implizit in bool konvertiert werden; Sie können nicht implizit in ganze Zahlen konvertiert werden. und sie können die meisten mathematischen Operationen nicht implizit ausführen. Sie sind undurchsichtige Werte.

Und daher sind sie ungeeignet für die Verwendung als Bitfelder. Der Versuch, enum class auf solch unangemessene Weise zu verwenden, wird nur zu einer Menge Casting führen. Benutze einfach ein normales altes enum und rette dir den Schmerz.

Answer 5

Ein kurzes Beispiel für Enum-Flags unten.

#indlude "enum_flags.h" 

ENUM_FLAGS(foo_t) 
enum class foo_t 
    { 
    none   = 0x00 
    ,a    = 0x01 
    ,b    = 0x02 
    }; 

ENUM_FLAGS(foo2_t) 
enum class foo2_t 
    { 
    none   = 0x00 
    ,d    = 0x01 
    ,e    = 0x02 
    }; 

int _tmain(int argc, _TCHAR* argv[]) 
    { 
    if(flags(foo_t::a & foo_t::b)) {}; 
    // if(flags(foo2_t::d & foo_t::b)) {}; // Type safety test - won't compile if uncomment 
    }; 

ENUM_FLAGS (T) ist ein Makro, definiert in enum_flags.h (weniger als 100 Linien, frei ohne Einschränkungen zu verwenden).

Answer 6

struct Error { 
    enum { 
     None  = 0, 
     Error1  = 1, 
     Error2  = 2, 
    } Value; 

    /* implicit */ Error(decltype(Value) value) : Value(value) {} 

    explicit operator bool() { 
     return Value != Error::None; 
    } 
}; 

inline bool operator==(Error a, Error b) { 
    return a.Value == b.Value; 
} 

inline bool operator!=(Error a, Error b) { 
    return !(a == b); 
} 

enum hat keine überladenen Operator für jetzt, so wickeln Sie es ein in class oder struct.

Answer 7

ich überlastete in der Regel den einstelligen + Operator für fahnenartige enum classes, so dass ich die folgenden Aktionen durchführen:

#define ENUM_FLAGS (FlagType, UnderlyingType)       \ 
    /* ... */               \ 
    UnderlyingType operator+(const FlagType &flags) {     \ 
      return static_cast<UnderlyingType>(flags)      \ 
    }                 \ 
    /* ... */               \ 
    FlagType operator&(const FlagType &lhs, const FlagType &rhs) {  \ 
      return static_cast<FlagType>(+lhs & +rhs)      \ 
    }                 \ 
    /* ... */               \ 
    FlagType &operator|=(FlagType &lhs, const FlagType &rhs) {   \ 
      return lhs = static_cast<FlagType>(+lhs | +rhs)    \ 
    }                 \ 
    /* ... */               \ 
    /***/ 

// .... 

enum class Flags: std::uint16_t { 
    NoFlag = 0x0000, 
    OneFlag = 0x0001, 
    TwoFlag = 0x0002, 
    // ....  
    LastFlag = 0x8000 
}; 

ENUM_FLAGS(Flags, std::uint16_t) 

auto flagVar = Flags::NoFlag; 

// ... 

flagVar |= Flags::OneFlag; 

// ... 

if (+(flagVar & Flags::OneFlag)) { 
    /// ... 
}