Wie kann ich eine enum-Klasse in einem booleschen Kontext?

Habe ich einige generische code, der funktioniert mit den flags angegeben, die mit C++11 enum class Arten. In einem Schritt, ich würde gerne wissen, ob irgendwelche bits im flag gesetzt sind. Derzeit bin ich mit dem code:

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

Konnte ich mich auch zwingen Benutzer, um geben Sie einen bestimmten Namen für einen all-null-Feld, das ist mehr lesbar, aber schränkt meine Namenskonventionen auf jeden es zu benutzen:

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

Aber weder dieser liest sich so schön wie die traditionellen:

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

Ist es möglich, geben Sie eine benutzerdefinierte Funktion auswerten eine Klasse enum in einem booleschen Kontext?

  • Gibt es einen bestimmten Grund, warum Sie nicht verwenden können, binäre flags? Sie sind sauber und effizient. Jedenfalls, enum-Klasse können keine Werte in zahlen umgewandelt werden. Sie haben auf die use-flags != E::keine wenn Sie aufzählen. Sie wissen, können Sie nur eine nicht-enum-Klasse und mit static const int was = 1, static const int whatever_else = 2...usw. und überlastung nur wenige Betreiber.
  • flags", was bedeutet was, bools? Als bitfields sind Sie oft IB/UB und mit der regelmäßigen Ausrichtung, ich würde nicht nennen Sie effizient, noch sauber, wenn ich brauche zu kopieren mehrere Dateien auf einmal. Ich sehe nicht den Wert in was static ints, konnte ich nur mit einem enum-und zumindest ein wenig Typ-Sicherheit.
  • "Ich konnte nur mit einem enum-und zumindest ein wenig Typ-Sicherheit." Dann müssen Sie akzeptieren, dass zusammen mit, dass Sie nicht mehr zu sprechen, über die bits.
  • Nein, habe ich nicht; eines der grundlegenden Punkte der enum-Klassen ist, dass Sie typesafe Möglichkeiten der Benennung einer bestimmten (set) - Wert-Darstellung(en). Es ist absolut gut zu sprechen, sowohl von bits und Typ-Sicherheit.
  • Sie reden über bits, die von bestimmten benannten Konstanten, sicher, aber nicht über die enum-Wert im Allgemeinen. Dies ist durch design und eine Gute Sache.
  • Enum-Klassen entfernen der implizite cast auf int, aber nicht verstecken oder ändern Sie den Wert der Repräsentation. Sie noch den Wert angeben, buchstäblich, können Sie immer noch static_cast eher als reinterpret_cast, und Sie können immer noch std::underlying_type.
  • In der Tat, wir Stimmen alle dafür. Aber diese Dinge existieren nur, um von enum zu den zugrunde liegenden Typ und zurück, nicht zu gehen von einem bestimmten Allgemeinen Wert des zugrunde liegende Typ der Enumeration.

InformationsquelleAutor | 2012-03-26
  1. 19

    Ist es möglich, geben Sie eine benutzerdefinierte Funktion auswerten eine Klasse enum in einem booleschen Kontext?

    Ja, aber nicht automatisch. Manuell aufrufen einer Funktion ist immer noch eleganter als die anderen alternativen.

    Wählen Sie einfach eine nette Funktion name, wie any und umzusetzen. Überlast Auflösung stellen Sie sicher, Ihre Funktion spielt gut mit allen anderen.

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

...

if ( any( flags ) ) {
    ...

    Sieht nett genug, um mich.

    Update:, wenn Sie wollen diese anwenden, um verschiedene enumeration-Typen, kann es sein, Vorlagen:

    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 auch für andere Dinge, und nie auf irgendwelche Nebenwirkungen oder Probleme :v) .

    Könnten Sie überspringen Sie die Eigenschaft, und legen Sie die SFINAE Zustand zu so etwas wie enum_type::none == enum_type::none nur überprüfen Sie das Vorhandensein von none und der Gleichheits-operator, aber das wäre weniger explizite und sicher.

    InformationsquelleAutor Potatoswatter
  2. 26

    Wie @RMatin sagt. Aber Sie könnten zu einer überlastung operator!

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

    So dass Sie verwenden können, die !!e idiom

    if(!!e) {
  ...
}
    • schön! Ich mag dieses besser als 'alle'. kombiniert mit der SFINAE Antwort, macht es für mich die beste Lösung.
    InformationsquelleAutor Johannes Schaub - litb
  3. 8

    Wenn Sie ein flags-Feld (dh: ein Bitfeld) ich würde stark beraten Sie nicht verwenden enum class für bitfields.

    Stark typisierte enums vorhanden sein stark typisierte. Es macht die Enumeratoren in etwas mehr als nur benannte Konstante Ganzzahlen, die den Weg regelmäßig enums sind. Die Idee ist, dass, wenn Sie eine variable eines enum class geben, so ist Ihr Inhalt sollte immer genau mit einem von der enumerator-Werte. Das ist, warum gibt es keine implizite Konvertierung von oder zu den integer-Typen.

    Aber das ist nicht das, was du tust. Du nimmst ein Bitfeld, das ist eine Komposition von Enumerators Werte. Diese Komposition ist nicht selbst eines dieser Werte; es ist eine Kombination von Ihnen. Daher sind Sie liegen, wenn Sie sagen, dass Sie unter der enum class Art; Sie sind wirklich nur für eine vorzeichenlose Ganzzahl, die könnte einer der enum class aufgelistet.

    Beispiel:

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

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

    val in diesem Fall nicht enthalten First, Second oder Third. Sie haben verloren starke Typisierung, da Sie nicht enthalten keine der Arten.

    enum class Werte nicht implizit konvertiert werden können, um bool; Sie können nicht implizit in Ganzzahlen konvertiert; und Sie können nicht implizit haben die meisten mathematischen Operationen auf diese. Sie sind undurchsichtig Werte.

    Und damit sind Sie ungeeignet für die Verwendung als bitfields. Der Versuch, mit enum class in solch unangemessener Weise führt das nur zu viel Gießen. Verwenden Sie einfach regelmäßig alte enum und sparen Sie sich den Schmerz.

    • "Du hast verloren, starke Typisierung, da Sie nicht enthalten keine der Arten." Du meinst, es enthält keine der vordefinierten Werte. Das bedeutet nicht, dass ich gemacht habe jede Besondere Art von Art Verletzung. Darüber hinaus sind Sie in nicht undurchsichtig Werte - Ihr Wert-Darstellung definiert, in Bezug auf den zugrunde liegenden Speicher-Typ Sie sind lediglich explicit - Werte. Ich Schätze die Vermutung, dass die enum-Klassen nicht das richtige Werkzeug hier, aber zu sagen, was ich will, ist "illegal" anstatt "muss explizit auf den Punkt, wo es so ausführlich ist es nicht mehr wertvoll" ist ungenau.
    • Zuerst habe ich gesagt, dass der code, den ich schrieb, war illegal, was es wird. Sekunde, was Sie wollen erfordert eine Menge von expliziten und sinnlos wirft, was ist das problem, das Sie uns gebeten, zu lösen. Die Lösung ist, aufhören, Dinge, die explizite und sinnlos wirft. Drittens, es ist ein semantische Art der Verletzung. Der ganze Punkt, der mit starken Typisierung bei enums ist etwas syntaktische Zusicherung, dass die Werte übergeben werden, sind eine der gesetzlichen Werte. Ja, Menschen können Lügen, aber Sie haben zumindest zu werfen, das zu tun, was oft als ein Zeichen, etwas schattig.
    • -1: Lustig, ich antwortete nur noch eine Frage zu, wie enums sind ideal für Gruppen von flags. Das problem mit der ideone Beispiel ist, dass die operator| überlastung fehlt. enum Typen definiert sind, Folgen Sie den Wert Semantik der zugrunde liegende Typ, und wenn das unterstützt die bitweise Arithmetik, geben Sicherheit und rechnerische Sicherheit sind beide optimiert.
    • sind, ja. enum classes nicht. enum class Werte Folgen nicht Wert-Semantik. Sie sind stark typisierte; Sie sind nur für die Speicherung von einer der Enumerationswerte. So kann man nicht einfach jede Mathe auf Sie. Beachten Sie, dass die Ideaone code funktioniert, wenn Sie es ändern, um enum eher als enum class. Es ist auch illegal, die zahlen speichern, in einer enum class Variablen ohne expliziten cast. Also selbst wenn operator| gearbeitet, Sie müssen noch eine Besetzung, nur um speichern Sie die resultierende Wert.
    • auch illegale speichern von Rufnummern in eine enum-Klasse variabel, ohne einen expliziten cast. Also selbst wenn der Betreiber| gearbeitet, Sie müssen noch eine Besetzung, nur um speichern Sie die resultierende Wert." — ja, das ist genau das, was Sie tun würde. Wenn der Standard-Semantik nicht ausreichen, fügen Sie Anpassung. ideone.com/yLBZF
    • Dann was ist der Punkt, der mit einem enum class statt einer enum? Wenn Sie nur gehen, um cast away alle die starke Typisierung, es gibt wirklich keinen Sinn, es zu benutzen.
    • Denken Sie daran, dass diese Operatoren sind nicht vordefiniert an alle für enumeration types. In der Lage zu tun e1 | e2 für old-style-Zähler setzt auf die Umwandlung in int ersten. Es gibt keine Beziehung "Wert-Semantik" von einem enum-Typ gibt.
    • Da die Modelle werden sicher versteckt innerhalb einer Funktion. Als Implementierungs-detail der Implementierung einsetzen können, wo Sie sind sicher, um zu definieren, nur sichere Operationen. enum class ist nur in der Regel sicherer als enum. Es würde eine Menge Arbeit, um wirklich alle beseitigen zusätzliche Sicherheit.
    • lassen Sie uns weiter, diese Diskussion im chat
    • Ich möchte nur darauf hinweisen, dass Microsoft Visual Studio eigentlich richtig zeigen Flagge-basierte class-enums richtig in IntelliSense tooltips und anderen Kontexten korrekt, wenn mehrere flags angegeben werden.

    InformationsquelleAutor Nicol Bolas
  4. 7
    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 überladene operator für jetzt, so wickeln Sie es in ein class oder struct.

    InformationsquelleAutor kezhuw
  5. 6

    Nein, nicht so. Konvertierung müssen die Betreiber Mitglieder, und Enumerationen, die keine Mitglieder haben. Ich denke, das beste, was Sie tun können, ist der Vergleich mit none oder, wenn es nicht eine none enumerator, wickeln Sie die static_cast in einer Funktion.

    InformationsquelleAutor R. Martinho Fernandes
  6. 1

    Ich in der Regel überladen unärer + Betreiber für flag-wie enum classes, so dass ich Folgendes tun können:

    #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)) {
    ///...
}
    InformationsquelleAutor Péter Hanos-Puskai
  7. 0

    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 Zeilen, frei verwenden, ohne Einschränkungen).

    InformationsquelleAutor Yuri Yaryshev
Schreibe einen Kommentar