Aufzählung in modernem C ++ 11 / C ++ 14 / C ++ 17 und zukünftigem C ++ 20

Im Gegensatz zu allen anderen ähnlichen Fragen, diese Frage ist über die Verwendung des neuen C++ - Funktionen.

Nach der Lektüre viele Antworten, habe ich noch nicht finden:

Elegante Weise mit C++11 C++14 oder C++17 neue features
Oder etwas ready-to-use in Steigern
Sonst noch etwas geplant für C++20

Beispiel

Ein Beispiel ist oft besser als eine lange Erklärung.

Kompilieren Sie und führen Sie dieses snippet auf Coliru.

^{(Ein weiteres ehemaliges Beispiel ist auch verfügbar)}

#include <map>
#include <iostream>

struct MyClass
{
    enum class MyEnum : char {
        AAA = -8,
        BBB = '8',
        CCC = AAA + BBB
    };
};

//Replace magic() by some faster compile-time generated code
//(you're allowed to replace the return type with std::string
//if that's easier for you)
const char* magic (MyClass::MyEnum e)
{
    const std::map<MyClass::MyEnum,const char*> MyEnumStrings {
        { MyClass::MyEnum::AAA, "MyClass::MyEnum::AAA" },
        { MyClass::MyEnum::BBB, "MyClass::MyEnum::BBB" },
        { MyClass::MyEnum::CCC, "MyClass::MyEnum::CCC" }
    };
    auto   it  = MyEnumStrings.find(e);
    return it == MyEnumStrings.end() ? "Out of range" : it->second;
}

int main()
{
   std::cout << magic(MyClass::MyEnum::AAA) <<'\n';
   std::cout << magic(MyClass::MyEnum::BBB) <<'\n';
   std::cout << magic(MyClass::MyEnum::CCC) <<'\n';
}

Einschränkungen

Bitte keine wertvolle Vervielfältigung von andere Antworten oder Standard Verbindung.
Bitte vermeiden aufblasen makro-basiert Antwort, oder versuchen zu reduzieren, die #define Aufwand so minimal wie möglich.
Bitte keine manuellen enum -> string mapping.

Schön zu haben

Unterstützen enum die Werte ab einer Zahl von null Verschieden
Unterstützung negative enum Werte
Unterstützung fragmentiert enum Werte
Unterstützen class enum (C++11)
Unterstützen class enum : <type> dass alle zulässigen <type> (C++11)
Compile-Zeit (nicht Laufzeit) Umwandlungen in einen string

oder zumindest eine schnelle Ausführung zur Laufzeit (z.B. std::map ist keine gute Idee...)
constexpr (C++11, entspannt in C++14)
noexcept (C++11)
snippet C++14/C++17 freundliche
C++ Stand der Technik

Eine mögliche Idee könnte mit der C++ - compiler Funktionen zum generieren von C++ code bei der Kompilierung-Zeit mit meta-Programmierung tricks basieren auf variadic template class und constexpr Funktionen...

InformationsquelleAutor der Frage olibre | 2015-03-03

c c++c++14 c++17 c++20 enums

Dies ist ähnlich wie Yuri Finkelstein; jedoch nicht erforderlich, zu steigern. Ich bin mit einer Karte, die Sie zuweisen können, einen beliebigen Wert für die Enumerationen, um Sie.

Deklaration von enum-Klasse als:

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

Dem folgenden code wird automatisch erstellt die enum-Klasse und überlast:

'+' '+=' für std::string
'<<' für streams
'~", nur um zu konvertieren string (Beliebigen unären operator wird zu tun, aber ich persönlich mag es nicht, für Klarheit)
'*', um die Anzahl von enums

Keine Verstärkung erforderlich, die alle erforderlichen Funktionen zur Verfügung.

Code:

#include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

#define STRING_REMOVE_CHAR(str, ch) str.erase(std::remove(str.begin(), str.end(), ch), str.end())

std::vector<std::string> splitString(std::string str, char sep = ',') {
    std::vector<std::string> vecString;
    std::string item;

    std::stringstream stringStream(str);

    while (std::getline(stringStream, item, sep))
    {
        vecString.push_back(item);
    }

    return vecString;
}

#define DECLARE_ENUM_WITH_TYPE(E, T, ...)                                                                     \
    enum class E : T                                                                                          \
    {                                                                                                         \
        __VA_ARGS__                                                                                           \
    };                                                                                                        \
    std::map<T, std::string> E##MapName(generateEnumMap<T>(#__VA_ARGS__));                                    \
    std::ostream &operator<<(std::ostream &os, E enumTmp)                                                     \
    {                                                                                                         \
        os << E##MapName[static_cast<T>(enumTmp)];                                                            \
        return os;                                                                                            \
    }                                                                                                         \
    size_t operator*(E enumTmp) { (void) enumTmp; return E##MapName.size(); }                                 \
    std::string operator~(E enumTmp) { return E##MapName[static_cast<T>(enumTmp)]; }                          \
    std::string operator+(std::string &&str, E enumTmp) { return str + E##MapName[static_cast<T>(enumTmp)]; } \
    std::string operator+(E enumTmp, std::string &&str) { return E##MapName[static_cast<T>(enumTmp)] + str; } \
    std::string &operator+=(std::string &str, E enumTmp)                                                      \
    {                                                                                                         \
        str += E##MapName[static_cast<T>(enumTmp)];                                                           \
        return str;                                                                                           \
    }                                                                                                         \
    E operator++(E &enumTmp)                                                                                  \
    {                                                                                                         \
        auto iter = E##MapName.find(static_cast<T>(enumTmp));                                                 \
        if (iter == E##MapName.end() || std::next(iter) == E##MapName.end())                                  \
            iter = E##MapName.begin();                                                                        \
        else                                                                                                  \
        {                                                                                                     \
            ++iter;                                                                                           \
        }                                                                                                     \
        enumTmp = static_cast<E>(iter->first);                                                                \
        return enumTmp;                                                                                       \
    }                                                                                                         \
    bool valid##E(T value) { return (E##MapName.find(value) != E##MapName.end()); }

#define DECLARE_ENUM(E, ...) DECLARE_ENUM_WITH_TYPE(E, int32_t, __VA_ARGS__)
template <typename T>
std::map<T, std::string> generateEnumMap(std::string strMap)
{
    STRING_REMOVE_CHAR(strMap, ' ');
    STRING_REMOVE_CHAR(strMap, '(');

    std::vector<std::string> enumTokens(splitString(strMap));
    std::map<T, std::string> retMap;
    T inxMap;

    inxMap = 0;
    for (auto iter = enumTokens.begin(); iter != enumTokens.end(); ++iter)
    {
        //Token: [EnumName | EnumName=EnumValue]
        std::string enumName;
        T enumValue;
        if (iter->find('=') == std::string::npos)
        {
            enumName = *iter;
        }
        else
        {
            std::vector<std::string> enumNameValue(splitString(*iter, '='));
            enumName = enumNameValue[0];
            //inxMap = static_cast<T>(enumNameValue[1]);
            if (std::is_unsigned<T>::value)
            {
                inxMap = static_cast<T>(std::stoull(enumNameValue[1], 0, 0));
            }
            else
            {
                inxMap = static_cast<T>(std::stoll(enumNameValue[1], 0, 0));
            }
        }
        retMap[inxMap++] = enumName;
    }

    return retMap;
}

Beispiel:

DECLARE_ENUM_WITH_TYPE(TestEnumClass, int32_t, ZERO = 0x00, TWO = 0x02, ONE = 0x01, THREE = 0x03, FOUR);

int main(void) {
    TestEnumClass first, second;
    first = TestEnumClass::FOUR;
    second = TestEnumClass::TWO;

    std::cout << first << "(" << static_cast<uint32_t>(first) << ")" << std::endl; //FOUR(4)

    std::string strOne;
    strOne = ~first;
    std::cout << strOne << std::endl; //FOUR

    std::string strTwo;
    strTwo = ("Enum-" + second) + (TestEnumClass::THREE + "-test");
    std::cout << strTwo << std::endl; //Enum-TWOTHREE-test

    std::string strThree("TestEnumClass: ");
    strThree += second;
    std::cout << strThree << std::endl; //TestEnumClass: TWO
    std::cout << "Enum count=" << *first << std::endl;
}

können Sie den code ausführen hier

InformationsquelleAutor der Antwort Danilo Ramos

_{(Der Ansatz der better_enums Bibliothek)}

Gibt es einen Weg, um enum zu string in der aktuellen C++ sieht das so aus:

ENUM(Channel, char, Red = 1, Green, Blue)

//"Same as":
//enum class Channel : char { Red = 1, Green, Blue };

Verwendung:

Channel     c = Channel::_from_string("Green");  //Channel::Green (2)
c._to_string();                                  //string "Green"

for (Channel c : Channel::_values())
    std::cout << c << std::endl;

//And so on...

Alle Operationen vorgenommen werden können constexpr. Sie können auch der Umsetzung der C++17 Reflexion Vorschlag erwähnt in der Antwort von @ecatmur.

Es ist nur ein makro. Ich glaube, das ist das minimum möglich, da der Präprozessor stringization (#) ist der einzige Weg, um zu konvertieren ein Zeichen, um eine Zeichenfolge in der aktuellen C++.
Das makro ist ziemlich unauffällig – der-Konstanten-Deklarationen, Initialisierungen einschließlich, sind eingefügt in ein built-in der enum-Deklaration. Das heißt, Sie haben die gleiche syntax und Bedeutung wie in a built-in enum.
Wiederholung ausgeschlossen ist.
Die Umsetzung ist die meisten natürlichen und nützlich, mindestens C++11, aufgrund constexpr. Es kann auch gemacht werden, um die Arbeit mit C++98 + __VA_ARGS__. Es ist definitiv modern C++.

Makro-definition ist etwas umständlich, so bin ich der Antwort auf diese in mehrfacher Hinsicht.

Der größte Teil dieser Antwort ist eine Implementierung, die ich denke, ist geeignet für die Platzverhältnisse auf StackOverflow.
Es gibt auch eine CodeProject-Artikel beschreibt die Grundlagen der Umsetzung in eine long-form-tutorial. [Soll ich es verschieben hier? Ich denke, es ist zu viel für eine SO beantworten].
Es ist ein full-featured-Bibliothek "Besser Enums" implementiert, dass das makro in einer einzigen header-Datei. Es implementiert auch N4428 Type-Eigenschaft Abfragendie laufende revision des C++17 Reflexion Vorschlag N4113. Also, zumindest für Enumerationen deklariert durch dieses makro können Sie den vorgeschlagenen C++17 enum-Reflexion jetzt in C++11/C++14.

Es ist einfach zu erweitern, die eine Antwort auf die Funktionen der Bibliothek – nichts "wichtiges" ist weggelassen. Es ist allerdings Recht mühsam, und es gibt compiler-Portabilität betrifft.

Haftungsausschluss: ich bin der Autor sowohl der CodeProject-Artikel und die Bibliothek.

Können Sie versuchen, die code in diese Antwort die Bibliothekund die Umsetzung der N4428 live-online-in der Wandbox. Die Bibliothek enthält auch ein überblick über die Verwendung von es als N4428die erklärt, Enumerationen, die Teil des Vorschlags.

Erklärung

Den code unten implementiert Konvertierungen zwischen enums und strings. Jedoch, es kann erweitert werden um andere Dinge wie iteration. Diese Antwort umschließt eine enum in einem struct. Sie können auch generieren eine Eigenschaften struct neben einer enum-statt.

Die Strategie zu generieren, so etwas wie dieses:

struct Channel {
    enum _enum : char { __VA_ARGS__ };
    constexpr static const Channel          _values[] = { __VA_ARGS__ };
    constexpr static const char * const     _names[] = { #__VA_ARGS__ };

    static const char* _to_string(Channel v) { /* easy */ }
    constexpr static Channel _from_string(const char *s) { /* easy */ }
};

Probleme sind:

Wir am Ende mit etwas wie {Red = 1, Green, Blue} als Initialisierung für die Werte-array. Dies gilt nicht C++, weil Red ist nicht ein zuweisbarer Ausdruck. Dieses Problem ist durch die casting-jede Konstante eines Typs T dass eine Zuordnung Betreiber, aber drop die Zuordnung: {(T)Red = 1, (T)Green, (T)Blue}.
Ähnlich, wir werden am Ende mit {"Red = 1", "Green", "Blue"} als Initialisierung für das names-array. Wir müssen schneiden Sie die " = 1". Ich bin mir nicht bewusst eine großartige Möglichkeit, um dies zu tun zur compile-Zeit, so werden wir verschieben diese zur Laufzeit. Als Ergebnis _to_string nicht constexpraber _from_string noch constexprdenn wir können die Behandlung von whitespace-Zeichen ist-gleich-Zeichen als Abschlusszeichen beim Vergleich mit unbeschnittenen strings.
Beide brauchen eine "mapping" - makro, kann ein anderes makro auf jedes element in __VA_ARGS__. Das ist ziemlich standard. Diese Antwort enthält auch eine einfache version, die kann mit bis zu 8 Elementen.
Wenn das makro ist wirklich eigenständig, es muss deklarieren Sie keine statischen Daten erfordert eine separate definition. In der Praxis bedeutet dies, arrays benötigen eine Besondere Behandlung. Es gibt zwei mögliche Lösungen: constexpr (oder nur const) - arrays im namespace-Gültigkeitsbereich, oder regelmäßige arrays in nicht-constexpr statische inline-Funktionen. Der code in dieser Antwort ist für C++11 und nimmt den ehemaligen Ansatz. Der CodeProject-Artikel ist für C++98 und nimmt den letzteren.

Code

#include <cstddef>      //For size_t.
#include <cstring>      //For strcspn, strncpy.
#include <stdexcept>    //For runtime_error.



//A "typical" mapping macro. MAP(macro, a, b, c, ...) expands to
//macro(a) macro(b) macro(c) ...
//The helper macro COUNT(a, b, c, ...) expands to the number of
//arguments, and IDENTITY(x) is needed to control the order of
//expansion of __VA_ARGS__ on Visual C++ compilers.
#define MAP(macro, ...) \
    IDENTITY( \
        APPLY(CHOOSE_MAP_START, COUNT(__VA_ARGS__)) \
            (macro, __VA_ARGS__))

#define CHOOSE_MAP_START(count) MAP ## count

#define APPLY(macro, ...) IDENTITY(macro(__VA_ARGS__))

#define IDENTITY(x) x

#define MAP1(m, x)      m(x)
#define MAP2(m, x, ...) m(x) IDENTITY(MAP1(m, __VA_ARGS__))
#define MAP3(m, x, ...) m(x) IDENTITY(MAP2(m, __VA_ARGS__))
#define MAP4(m, x, ...) m(x) IDENTITY(MAP3(m, __VA_ARGS__))
#define MAP5(m, x, ...) m(x) IDENTITY(MAP4(m, __VA_ARGS__))
#define MAP6(m, x, ...) m(x) IDENTITY(MAP5(m, __VA_ARGS__))
#define MAP7(m, x, ...) m(x) IDENTITY(MAP6(m, __VA_ARGS__))
#define MAP8(m, x, ...) m(x) IDENTITY(MAP7(m, __VA_ARGS__))

#define EVALUATE_COUNT(_1, _2, _3, _4, _5, _6, _7, _8, count, ...) \
    count

#define COUNT(...) \
    IDENTITY(EVALUATE_COUNT(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1))



//The type "T" mentioned above that drops assignment operations.
template <typename U>
struct ignore_assign {
    constexpr explicit ignore_assign(U value) : _value(value) { }
    constexpr operator U() const { return _value; }

    constexpr const ignore_assign& operator =(int dummy) const
        { return *this; }

    U   _value;
};



//Prepends "(ignore_assign<_underlying>)" to each argument.
#define IGNORE_ASSIGN_SINGLE(e) (ignore_assign<_underlying>)e,
#define IGNORE_ASSIGN(...) \
    IDENTITY(MAP(IGNORE_ASSIGN_SINGLE, __VA_ARGS__))

//Stringizes each argument.
#define STRINGIZE_SINGLE(e) #e,
#define STRINGIZE(...) IDENTITY(MAP(STRINGIZE_SINGLE, __VA_ARGS__))



//Some helpers needed for _from_string.
constexpr const char    terminators[] = " =\t\r\n";

//The size of terminators includes the implicit '\0'.
constexpr bool is_terminator(char c, size_t index = 0)
{
    return
        index >= sizeof(terminators) ? false :
        c == terminators[index] ? true :
        is_terminator(c, index + 1);
}

constexpr bool matches_untrimmed(const char *untrimmed, const char *s,
                                 size_t index = 0)
{
    return
        is_terminator(untrimmed[index]) ? s[index] == '\0' :
        s[index] != untrimmed[index] ? false :
        matches_untrimmed(untrimmed, s, index + 1);
}



//The macro proper.
//
//There are several "simplifications" in this implementation, for the
//sake of brevity. First, we have only one viable option for declaring
//constexpr arrays: at namespace scope. This probably should be done
//two namespaces deep: one namespace that is likely to be unique for
//our little enum "library", then inside it a namespace whose name is
//based on the name of the enum to avoid collisions with other enums.
//I am using only one level of nesting.
//
//Declaring constexpr arrays inside the struct is not viable because
//they will need out-of-line definitions, which will result in
//duplicate symbols when linking. This can be solved with weak
//symbols, but that is compiler- and system-specific. It is not
//possible to declare constexpr arrays as static variables in
//constexpr functions due to the restrictions on such functions.
//
//Note that this prevents the use of this macro anywhere except at
//namespace scope. Ironically, the C++98 version of this, which can
//declare static arrays inside static member functions, is actually
//more flexible in this regard. It is shown in the CodeProject
//article.
//
//Second, for compilation performance reasons, it is best to separate
//the macro into a "parametric" portion, and the portion that depends
//on knowing __VA_ARGS__, and factor the former out into a template.
//
//Third, this code uses a default parameter in _from_string that may
//be better not exposed in the public interface.

#define ENUM(EnumName, Underlying, ...)                               \
namespace data_ ## EnumName {                                         \
    using _underlying = Underlying;                                   \
    enum { __VA_ARGS__ };                                             \
                                                                      \
    constexpr const size_t           _size =                          \
        IDENTITY(COUNT(__VA_ARGS__));                                 \
                                                                      \
    constexpr const _underlying      _values[] =                      \
        { IDENTITY(IGNORE_ASSIGN(__VA_ARGS__)) };                     \
                                                                      \
    constexpr const char * const     _raw_names[] =                   \
        { IDENTITY(STRINGIZE(__VA_ARGS__)) };                         \
}                                                                     \
                                                                      \
struct EnumName {                                                     \
    using _underlying = Underlying;                                   \
    enum _enum : _underlying { __VA_ARGS__ };                         \
                                                                      \
    const char * _to_string() const                                   \
    {                                                                 \
        for (size_t index = 0; index < data_ ## EnumName::_size;      \
             ++index) {                                               \
                                                                      \
            if (data_ ## EnumName::_values[index] == _value)          \
                return _trimmed_names()[index];                       \
        }                                                             \
                                                                      \
        throw std::runtime_error("invalid value");                    \
    }                                                                 \
                                                                      \
    constexpr static EnumName _from_string(const char *s,             \
                                           size_t index = 0)          \
    {                                                                 \
        return                                                        \
            index >= data_ ## EnumName::_size ?                       \
                    throw std::runtime_error("invalid identifier") :  \
            matches_untrimmed(                                        \
                data_ ## EnumName::_raw_names[index], s) ?            \
                    (EnumName)(_enum)data_ ## EnumName::_values[      \
                                                            index] :  \
            _from_string(s, index + 1);                               \
    }                                                                 \
                                                                      \
    EnumName() = delete;                                              \
    constexpr EnumName(_enum value) : _value(value) { }               \
    constexpr operator _enum() const { return (_enum)_value; }        \
                                                                      \
  private:                                                            \
    _underlying     _value;                                           \
                                                                      \
    static const char * const * _trimmed_names()                      \
    {                                                                 \
        static char     *the_names[data_ ## EnumName::_size];         \
        static bool     initialized = false;                          \
                                                                      \
        if (!initialized) {                                           \
            for (size_t index = 0; index < data_ ## EnumName::_size;  \
                 ++index) {                                           \
                                                                      \
                size_t  length =                                      \
                    std::strcspn(data_ ## EnumName::_raw_names[index],\
                                 terminators);                        \
                                                                      \
                the_names[index] = new char[length + 1];              \
                                                                      \
                std::strncpy(the_names[index],                        \
                             data_ ## EnumName::_raw_names[index],    \
                             length);                                 \
                the_names[index][length] = '\0';                      \
            }                                                         \
                                                                      \
            initialized = true;                                       \
        }                                                             \
                                                                      \
        return the_names;                                             \
    }                                                                 \
};

und

//The code above was a "header file". This is a program that uses it.
#include <iostream>
#include "the_file_above.h"

ENUM(Channel, char, Red = 1, Green, Blue)

constexpr Channel   channel = Channel::_from_string("Red");

int main()
{
    std::cout << channel._to_string() << std::endl;

    switch (channel) {
        case Channel::Red:   return 0;
        case Channel::Green: return 1;
        case Channel::Blue:  return 2;
    }
}

static_assert(sizeof(Channel) == sizeof(char), "");

Dem oben genannten Programm druckt Redwie man es erwarten würde. Es ist eine gewisse Art der Sicherheit, denn Sie können nicht erstellen ein enum ohne es zu initialisieren und löschen der Fälle aus der switch resultieren in einer Warnung vom compiler (je nach compiler und flags). Beachten Sie auch, dass "Red" umgewandelt wurde zu enum bei der Kompilierung.

InformationsquelleAutor der Antwort antron

60

~~C++17~~ C++ - 20, Sie werden daran interessiert sein in der Arbeit der Reflexion Study Group (SG7). Gibt es eine parallele Reihe von Publikationen zu Wortlaut (P0194) und Grundlagen, design und Entwicklung (P0385). (Links lösen, um die neuesten Papier in jeder Serie.)

Als der P0194r2 (2016-10-15), die syntax wäre die vorgeschlagene reflexpr Stichwort:
```
meta::get_base_name_v<
  meta::get_element_m<
    meta::get_enumerators_m<reflexpr(MyEnum)>,
    0>
  >
```
Beispiel (adaptiert von Matus Choclik ist reflexpr Zweig von clang):
```
#include <reflexpr>
#include <iostream>

enum MyEnum { AAA = 1, BBB, CCC = 99 };

int main()
{
  auto name_of_MyEnum_0 = 
    std::meta::get_base_name_v<
      std::meta::get_element_m<
        std::meta::get_enumerators_m<reflexpr(MyEnum)>,
        0>
    >;

  //prints "AAA"
  std::cout << name_of_MyEnum_0 << std::endl;
}
```
Statische Reflexion es nicht geschafft, in C++17 (eher in die wohl endgültige Entwurf vorgestellt im November 2016 Normen-Tagung in Issaquah), aber es gibt ein Vertrauen, dass es in C++20; von Herb Sutter-Reise-Bericht:

Insbesondere die Reflexion study group bewertet die neuesten zusammengeführt statische Reflexion Vorschlag und fand ihn bereit, um in den Haupt-Evolution-Gruppen bei unserem nächsten treffen zu überlegen, die unified statische Reflexion Vorschlag für eine TS oder für den nächsten standard.

InformationsquelleAutor der Antwort ecatmur
13

Zurück im Jahr 2011 verbrachte ich ein Wochenende fine-tuning ein makro-basierte Lösung und endete nie, es zu benutzen.

Meine aktuelle Vorgehensweise ist, Vim zu starten, kopieren Sie die Enumeratoren in einem leeren Schalter Körper, beginnen Sie ein neues makro auf, transformieren Sie die erste enumerator in einer case-Anweisung, bewegen Sie den cursor an den Anfang der nächsten Zeile makro stoppen und erzeugen Sie die restlichen case-Anweisungen durch ausführen des Makros auf der anderen aufgelistet.

Vim-Makros sind mehr Spaß als C++ - Makros.

Real-life-Beispiel:
```
enum class EtherType : uint16_t
{
    ARP   = 0x0806,
    IPv4  = 0x0800,
    VLAN  = 0x8100,
    IPv6  = 0x86DD
};
```
Werde ich erstellen:
```
std::ostream& operator<< (std::ostream& os, EtherType ethertype)
{
    switch (ethertype)
    {
        case EtherType::ARP : return os << "ARP" ;
        case EtherType::IPv4: return os << "IPv4";
        case EtherType::VLAN: return os << "VLAN";
        case EtherType::IPv6: return os << "IPv6";
        //omit default case to trigger compiler warning for missing cases
    };
    return os << static_cast<std::uint16_t>(ethertype);
}
```
Und das ist, wie ich durch zu bekommen.

Native Unterstützung für enum stringification wäre viel besser, wenn. Ich bin sehr daran interessiert zu sehen, die Ergebnisse der Reflexion Arbeitsgruppen in C++17.

Einen alternativen Weg, es zu tun war, gepostet von @sehe in der Kommentare.

InformationsquelleAutor der Antwort StackedCrooked

Ich weiß nicht, wenn du gehst, es zu mögen oder nicht, ich bin nicht Recht glücklich mit dieser Lösung, aber es ist ein C++14 freundliche Ansatz, weil es mit template-Variablen und missbrauchen template-Spezialisierung:

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

template<MyEnum> const char MyEnumName[] = "Invalid MyEnum value";
template<> const char MyEnumName<MyEnum::AAA>[] = "AAA";
template<> const char MyEnumName<MyEnum::BBB>[] = "BBB";
template<> const char MyEnumName<MyEnum::CCC>[] = "CCC";

int main()
{
    //Prints "AAA"
    std::cout << MyEnumName<MyEnum::AAA> << '\n';
    //Prints "Invalid MyEnum value"
    std::cout << MyEnumName<static_cast<MyEnum>(0x12345678)> << '\n';
    //Well... in fact it prints "Invalid MyEnum value" for any value
    //different of MyEnum::AAA, MyEnum::BBB or MyEnum::CCC.

    return 0;
}

Das Schlimmste über diesen Ansatz ist, dass ist ein Schmerz zu erhalten, aber es ist auch ein Schmerz zu halten einige andere ähnliche aproaches, nicht wahr?

Gute Punkte über diese Zufahrt:

Mit variabler tempates (C++14-Funktion)
Mit der template Spezialisierung können wir "erkennen", wenn ein Ungültiger Wert verwendet wird (aber ich bin mir nicht sicher, ob das nützlich sein könnte).
Es sieht gut aus.
Der name-lookup erfolgt zur compile-Zeit.

Live-Beispiel

Bearbeiten

Geheimnissvolle user673679 du hast Recht; die C++ - 14-variable template-Ansatz ist es nicht, behandelt die Laufzeit Fall war es mein Fehler ist es zu vergessen 🙁

Aber wir können immer noch einige moderne C++ - Funktionen und-Variablen template-plus variadic template-Tricks zum erzielen einer runtime-übersetzung von enum-Wert zu string... es ist so lästig, wie die anderen, aber immer noch Wert zu erwähnen.

Beginnen wir mit einem template-alias zu verkürzen, die Zugang zu einer enum-string anzeigen:

//enum_map contains pairs of enum value and value string for each enum
//this shortcut allows us to use enum_map<whatever>.
template <typename ENUM>
using enum_map = std::map<ENUM, const std::string>;

//This variable template will create a map for each enum type which is
//instantiated with.
template <typename ENUM>
enum_map<ENUM> enum_values{};

Dann, das variadic template-Tricks:

template <typename ENUM>
void initialize() {}

template <typename ENUM, typename ... args>
void initialize(const ENUM value, const char *name, args ... tail)
{
    enum_values<ENUM>.emplace(value, name);
    initialize<ENUM>(tail ...);
}

"Best trick" ist hier die Verwendung von variable Vorlage für die Karte, die enthält die Werte und Namen der einzelnen enum-Eintrag; dieser Karte werden die gleichen in jeder übersetzungseinheit und haben den gleichen Namen überall so ist Recht unkompliziert und ordentlich, wenn wir die initialize Funktion wie diese:

initialize
(
    MyEnum::AAA, "AAA",
    MyEnum::BBB, "BBB",
    MyEnum::CCC, "CCC"
);

Sind wir asigning Namen zu jeder MyEnum Eintrag und verwendet werden können-Laufzeit:

std::cout << enum_values<MyEnum>[MyEnum::AAA] << '\n';

Kann aber verbessert werden mit SFINAE und überlastung << Betreiber:

template<typename ENUM, class = typename std::enable_if<std::is_enum<ENUM>::value>::type>
std::ostream &operator <<(std::ostream &o, const ENUM value)
{
    static const std::string Unknown{std::string{typeid(ENUM).name()} + " unknown value"};
    auto found = enum_values<ENUM>.find(value);

    return o << (found == enum_values<ENUM>.end() ? Unknown : found->second);
}

Mit der richtigen operator << nun können wir die enum-so:

std::cout << MyEnum::AAA << '\n';

Dies ist auch lästig zu erhalten und verbessert werden kann, aber hoffe, Sie bekommen die Idee.

Live-Beispiel

InformationsquelleAutor der Antwort Paula_plus_plus

Ich hatte das gleiche problem vor ein paar Tagen. Ich konnte nicht finden, dass jeder C++ - Lösung, ohne einige seltsame makro-Magie, also entschied ich mich zu schreiben ein CMake-code-generator zu generieren, einfach switch-case-Anweisungen.

Verwendung:

enum2str_generate(
  PATH          <path to place the files in>
  CLASS_NAME    <name of the class (also prefix for the files)>
  FUNC_NAME     <name of the (static) member function>
  NAMESPACE     <the class will be inside this namespace>
  INCLUDES      <LIST of files where the enums are defined>
  ENUMS         <LIST of enums to process>
  BLACKLIST     <LIST of constants to ignore>
  USE_CONSTEXPR <whether to use constexpr or not (default: off)>
  USE_C_STRINGS <whether to use c strings instead of std::string or not (default: off)>
)

Die Funktion durchsucht die include-Dateien im Dateisystem (verwendet die include-Verzeichnisse zur Verfügung, mit der include_directories Befehl), liest Sie und hat einige regex zu generieren, die Klasse und die Funktion(en).

HINWEIS: constexpr impliziert inline in C++, so dass mit dem USE_CONSTEXPR option erzeugt einen header nur Klasse!

Beispiel:

./includes/ein.h:

enum AAA : char { A1, A2 };

typedef enum {
   VAL1          = 0,
   VAL2          = 1,
   VAL3          = 2,
   VAL_FIRST     = VAL1,    //Ignored
   VAL_LAST      = VAL3,    //Ignored
   VAL_DUPLICATE = 1,       //Ignored
   VAL_STRANGE   = VAL2 + 1 //Must be blacklisted
} BBB;

./CMakeLists.txt:

include_directories( ${PROJECT_SOURCE_DIR}/includes ...)

enum2str_generate(
   PATH       "${PROJECT_SOURCE_DIR}"
   CLASS_NAME "enum2Str"
   NAMESPACE  "abc"
   FUNC_NAME  "toStr"
   INCLUDES   "a.h" # WITHOUT directory
   ENUMS      "AAA" "BBB"
   BLACKLIST  "VAL_STRANGE")

Generiert:

./enum2Str.hpp:

/*!
  * \file enum2Str.hpp
  * \warning This is an automatically generated file!
  */

#ifndef ENUM2STR_HPP
#define ENUM2STR_HPP

#include <string>
#include <a.h>

namespace abc {

class enum2Str {
 public:
   static std::string toStr( AAA _var ) noexcept;
   static std::string toStr( BBB _var ) noexcept;
};

}

#endif //ENUM2STR_HPP

./enum2Str.cpp:

/*!
  * \file enum2Str.cpp
  * \warning This is an automatically generated file!
  */

#include "enum2Str.hpp"

namespace abc {

/*!
 * \brief Converts the enum AAA to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( AAA _var ) noexcept {
   switch ( _var ) {
      case A1: return "A1";
      case A2: return "A2";
      default: return "<UNKNOWN>";
   }
}

/*!
 * \brief Converts the enum BBB to a std::string
 * \param _var The enum value to convert
 * \returns _var converted to a std::string
 */
std::string enum2Str::toStr( BBB _var ) noexcept {
   switch ( _var ) {
      case VAL1: return "VAL1";
      case VAL2: return "VAL2";
      case VAL3: return "VAL3";
      default: return "<UNKNOWN>";
   }
}
}

Update:

Das script unterstützt jetzt auch den Gültigkeitsbereich Enumerationen (enum class|struct) und
Ich zog es an ein separates repo mit ein paar anderen scripts, die ich oft verwenden: https://github.com/mensinda/cmakeBuildTools

InformationsquelleAutor der Antwort Mense

Wenn Ihr enum sieht aus wie

enum MyEnum
{
  AAA = -8,
  BBB = '8',
  CCC = AAA + BBB
};

Können Sie den Inhalt der enum in eine neue Datei:

AAA = -8,
BBB = '8',
CCC = AAA + BBB

Und dann die Werte sein kann, umgeben von einem makro:

//default definition
#ifned ITEM(X,Y)
#define ITEM(X,Y)
#endif

//Items list
ITEM(AAA,-8)
ITEM(BBB,'8')
ITEM(CCC,AAA+BBB)

//clean up
#undef ITEM

Nächste Schritt kann sein, die Gegenstände in der enum wieder:

enum MyEnum
{
  #define ITEM(X,Y) X=Y,
  #include "enum_definition_file"
};

Und schließlich können Sie generieren utility-Funktionen über dieses enum:

std::string ToString(MyEnum value)
{
  switch( value )
  {
    #define ITEM(X,Y) case X: return #X;
    #include "enum_definition_file"
  }

  return "";
}

MyEnum FromString(std::string const& value)
{
  static std::map<std::string,MyEnum> converter
  {
    #define ITEM(X,Y) { #X, X },
    #include "enum_definition_file"
  };

  auto it = converter.find(value);
  if( it != converter.end() )
    return it->second;
  else
    throw std::runtime_error("Value is missing");
}

Die Lösung angewendet werden können, um älteren C++ - standards, und es nicht die Verwendung moderner C++ - Elemente, aber es kann verwendet werden, generiert viel code, ohne zu viel Aufwand und Pflege.

InformationsquelleAutor der Antwort eferion

Wie pro Antrag von der OP, hier eine abgespeckte version, die hässlichen makro-Lösung, basierend auf Boost Preprosessor und Variadic Makros.

Er ermöglicht eine einfache Liste wie die syntax der enumerator-Elemente zusammen mit dem setzen der Werte für die einzelnen Elemente, so dass

XXX_ENUM(foo,(a,b,(c,42)));

erweitert, um

enum foo {
    a,
    b,
    c=42
};

Neben den erforderlichen Funktionen zur Ausgabe und einige Konvertierung zurück. Dieses makro wurde, um hier für Alter, und ich bin nicht ganz sicher, dass der effizienteste Weg, oder es wird eine konforme Art und Weise, aber es ist seitdem arbeiten

Den kompletten code in Aktion gesehen werden kann an beiden Ideone und Coliru.

Ihre monströse Hässlichkeit ist oben; ich würde es hinter Spoiler um Ihre Augen zu schützen, wenn ich wüsste wie, aber markdown mag mich nicht.

Der Bibliothek (verschmolzen in einer einzigen header-Datei)

#include <boost/preprocessor.hpp>
#include <string>
#include <unordered_map>

namespace xxx
{

template<class T>
struct enum_cast_adl_helper { };

template<class E>
E enum_cast( const std::string& s )
{
    return do_enum_cast(s,enum_cast_adl_helper<E>());
}

template<class E>
E enum_cast( const char* cs )
{
    std::string s(cs);
    return enum_cast<E>(s);
}

} //namespace xxx

#define XXX_PP_ARG_N(                             \
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N

#define XXX_PP_RSEQ_N()                 \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0 

#define XXX_PP_NARG_(...) XXX_PP_ARG_N(__VA_ARGS__)
#define XXX_PP_NARG(...)  XXX_PP_NARG_(__VA_ARGS__,XXX_PP_RSEQ_N())
#define XXX_TUPLE_SIZE_INTERNAL(TUPLE) XXX_PP_NARG TUPLE

#define XXX_TUPLE_CHOICE(i)                            \
  BOOST_PP_APPLY(                                      \
    BOOST_PP_TUPLE_ELEM(                               \
      25, i, (                                         \
        (0), (1), (2), (3), (4), (5), (6), (7), (8),   \
        (9), (10), (11), (12), (13), (14), (15), (16), \
        (17), (18), (19), (20), (21), (22), (23), (24) \
  ) ) )

#define BOOST_PP_BOOL_00  BOOST_PP_BOOL_0
#define BOOST_PP_BOOL_01  BOOST_PP_BOOL_1
#define BOOST_PP_BOOL_02  BOOST_PP_BOOL_2
#define BOOST_PP_BOOL_03  BOOST_PP_BOOL_3
#define BOOST_PP_BOOL_04  BOOST_PP_BOOL_4
#define BOOST_PP_BOOL_05  BOOST_PP_BOOL_5
#define BOOST_PP_BOOL_06  BOOST_PP_BOOL_6
#define BOOST_PP_BOOL_07  BOOST_PP_BOOL_7
#define BOOST_PP_BOOL_08  BOOST_PP_BOOL_8
#define BOOST_PP_BOOL_09  BOOST_PP_BOOL_9
#define BOOST_PP_BOOL_010 BOOST_PP_BOOL_10
#define BOOST_PP_BOOL_011 BOOST_PP_BOOL_11
#define BOOST_PP_BOOL_012 BOOST_PP_BOOL_12
#define BOOST_PP_BOOL_013 BOOST_PP_BOOL_13
#define BOOST_PP_BOOL_014 BOOST_PP_BOOL_14
#define BOOST_PP_BOOL_015 BOOST_PP_BOOL_15
#define BOOST_PP_BOOL_016 BOOST_PP_BOOL_16
#define BOOST_PP_BOOL_017 BOOST_PP_BOOL_17
#define BOOST_PP_BOOL_018 BOOST_PP_BOOL_18
#define BOOST_PP_BOOL_019 BOOST_PP_BOOL_19
#define BOOST_PP_BOOL_020 BOOST_PP_BOOL_20
#define BOOST_PP_BOOL_021 BOOST_PP_BOOL_21
#define BOOST_PP_BOOL_022 BOOST_PP_BOOL_22
#define BOOST_PP_BOOL_023 BOOST_PP_BOOL_23
#define BOOST_PP_BOOL_024 BOOST_PP_BOOL_24
#define BOOST_PP_BOOL_025 BOOST_PP_BOOL_25
#define BOOST_PP_BOOL_026 BOOST_PP_BOOL_26
#define BOOST_PP_BOOL_027 BOOST_PP_BOOL_27
#define BOOST_PP_BOOL_028 BOOST_PP_BOOL_28
#define BOOST_PP_BOOL_029 BOOST_PP_BOOL_29
#define BOOST_PP_BOOL_030 BOOST_PP_BOOL_30
#define BOOST_PP_BOOL_031 BOOST_PP_BOOL_31
#define BOOST_PP_BOOL_032 BOOST_PP_BOOL_32
#define BOOST_PP_BOOL_033 BOOST_PP_BOOL_33
#define BOOST_PP_BOOL_034 BOOST_PP_BOOL_34
#define BOOST_PP_BOOL_035 BOOST_PP_BOOL_35
#define BOOST_PP_BOOL_036 BOOST_PP_BOOL_36
#define BOOST_PP_BOOL_037 BOOST_PP_BOOL_37
#define BOOST_PP_BOOL_038 BOOST_PP_BOOL_38
#define BOOST_PP_BOOL_039 BOOST_PP_BOOL_39
#define BOOST_PP_BOOL_040 BOOST_PP_BOOL_40
#define BOOST_PP_BOOL_041 BOOST_PP_BOOL_41
#define BOOST_PP_BOOL_042 BOOST_PP_BOOL_42
#define BOOST_PP_BOOL_043 BOOST_PP_BOOL_43
#define BOOST_PP_BOOL_044 BOOST_PP_BOOL_44
#define BOOST_PP_BOOL_045 BOOST_PP_BOOL_45
#define BOOST_PP_BOOL_046 BOOST_PP_BOOL_46
#define BOOST_PP_BOOL_047 BOOST_PP_BOOL_47
#define BOOST_PP_BOOL_048 BOOST_PP_BOOL_48
#define BOOST_PP_BOOL_049 BOOST_PP_BOOL_49
#define BOOST_PP_BOOL_050 BOOST_PP_BOOL_50
#define BOOST_PP_BOOL_051 BOOST_PP_BOOL_51
#define BOOST_PP_BOOL_052 BOOST_PP_BOOL_52
#define BOOST_PP_BOOL_053 BOOST_PP_BOOL_53
#define BOOST_PP_BOOL_054 BOOST_PP_BOOL_54
#define BOOST_PP_BOOL_055 BOOST_PP_BOOL_55
#define BOOST_PP_BOOL_056 BOOST_PP_BOOL_56
#define BOOST_PP_BOOL_057 BOOST_PP_BOOL_57
#define BOOST_PP_BOOL_058 BOOST_PP_BOOL_58
#define BOOST_PP_BOOL_059 BOOST_PP_BOOL_59
#define BOOST_PP_BOOL_060 BOOST_PP_BOOL_60
#define BOOST_PP_BOOL_061 BOOST_PP_BOOL_61
#define BOOST_PP_BOOL_062 BOOST_PP_BOOL_62
#define BOOST_PP_BOOL_063 BOOST_PP_BOOL_63

#define BOOST_PP_DEC_00  BOOST_PP_DEC_0
#define BOOST_PP_DEC_01  BOOST_PP_DEC_1
#define BOOST_PP_DEC_02  BOOST_PP_DEC_2
#define BOOST_PP_DEC_03  BOOST_PP_DEC_3
#define BOOST_PP_DEC_04  BOOST_PP_DEC_4
#define BOOST_PP_DEC_05  BOOST_PP_DEC_5
#define BOOST_PP_DEC_06  BOOST_PP_DEC_6
#define BOOST_PP_DEC_07  BOOST_PP_DEC_7
#define BOOST_PP_DEC_08  BOOST_PP_DEC_8
#define BOOST_PP_DEC_09  BOOST_PP_DEC_9
#define BOOST_PP_DEC_010 BOOST_PP_DEC_10
#define BOOST_PP_DEC_011 BOOST_PP_DEC_11
#define BOOST_PP_DEC_012 BOOST_PP_DEC_12
#define BOOST_PP_DEC_013 BOOST_PP_DEC_13
#define BOOST_PP_DEC_014 BOOST_PP_DEC_14
#define BOOST_PP_DEC_015 BOOST_PP_DEC_15
#define BOOST_PP_DEC_016 BOOST_PP_DEC_16
#define BOOST_PP_DEC_017 BOOST_PP_DEC_17
#define BOOST_PP_DEC_018 BOOST_PP_DEC_18
#define BOOST_PP_DEC_019 BOOST_PP_DEC_19
#define BOOST_PP_DEC_020 BOOST_PP_DEC_20
#define BOOST_PP_DEC_021 BOOST_PP_DEC_21
#define BOOST_PP_DEC_022 BOOST_PP_DEC_22
#define BOOST_PP_DEC_023 BOOST_PP_DEC_23
#define BOOST_PP_DEC_024 BOOST_PP_DEC_24
#define BOOST_PP_DEC_025 BOOST_PP_DEC_25
#define BOOST_PP_DEC_026 BOOST_PP_DEC_26
#define BOOST_PP_DEC_027 BOOST_PP_DEC_27
#define BOOST_PP_DEC_028 BOOST_PP_DEC_28
#define BOOST_PP_DEC_029 BOOST_PP_DEC_29
#define BOOST_PP_DEC_030 BOOST_PP_DEC_30
#define BOOST_PP_DEC_031 BOOST_PP_DEC_31
#define BOOST_PP_DEC_032 BOOST_PP_DEC_32
#define BOOST_PP_DEC_033 BOOST_PP_DEC_33
#define BOOST_PP_DEC_034 BOOST_PP_DEC_34
#define BOOST_PP_DEC_035 BOOST_PP_DEC_35
#define BOOST_PP_DEC_036 BOOST_PP_DEC_36
#define BOOST_PP_DEC_037 BOOST_PP_DEC_37
#define BOOST_PP_DEC_038 BOOST_PP_DEC_38
#define BOOST_PP_DEC_039 BOOST_PP_DEC_39
#define BOOST_PP_DEC_040 BOOST_PP_DEC_40
#define BOOST_PP_DEC_041 BOOST_PP_DEC_41
#define BOOST_PP_DEC_042 BOOST_PP_DEC_42
#define BOOST_PP_DEC_043 BOOST_PP_DEC_43
#define BOOST_PP_DEC_044 BOOST_PP_DEC_44
#define BOOST_PP_DEC_045 BOOST_PP_DEC_45
#define BOOST_PP_DEC_046 BOOST_PP_DEC_46
#define BOOST_PP_DEC_047 BOOST_PP_DEC_47
#define BOOST_PP_DEC_048 BOOST_PP_DEC_48
#define BOOST_PP_DEC_049 BOOST_PP_DEC_49
#define BOOST_PP_DEC_050 BOOST_PP_DEC_50
#define BOOST_PP_DEC_051 BOOST_PP_DEC_51
#define BOOST_PP_DEC_052 BOOST_PP_DEC_52
#define BOOST_PP_DEC_053 BOOST_PP_DEC_53
#define BOOST_PP_DEC_054 BOOST_PP_DEC_54
#define BOOST_PP_DEC_055 BOOST_PP_DEC_55
#define BOOST_PP_DEC_056 BOOST_PP_DEC_56
#define BOOST_PP_DEC_057 BOOST_PP_DEC_57
#define BOOST_PP_DEC_058 BOOST_PP_DEC_58
#define BOOST_PP_DEC_059 BOOST_PP_DEC_59
#define BOOST_PP_DEC_060 BOOST_PP_DEC_60
#define BOOST_PP_DEC_061 BOOST_PP_DEC_61
#define BOOST_PP_DEC_062 BOOST_PP_DEC_62
#define BOOST_PP_DEC_063 BOOST_PP_DEC_63

#define XXX_TO_NUMx(x) 0 ## x
#define XXX_TO_NUM(x) BOOST_PP_ADD(0,XXX_TO_NUMx(x))
#define XXX_STRINGIZEX(x) # x
#define XXX_VSTRINGIZE_SINGLE(a,b,x) XXX_STRINGIZE(x)
#define XXX_VSTRINGIZE_TUPLE(tpl) XXX_TUPLE_FOR_EACH(XXX_VSTRINGIZE_SINGLE,,tpl)
#define XXX_TUPLE_SIZE(TUPLE) XXX_TO_NUM(XXX_TUPLE_CHOICE(XXX_TUPLE_SIZE_INTERNAL(TUPLE)))
#define XXX_TUPLE_FOR_EACH(MACRO,DATA,TUPLE) BOOST_PP_LIST_FOR_EACH(MACRO,DATA,BOOST_PP_TUPLE_TO_LIST(XXX_TUPLE_SIZE(TUPLE),TUPLE))
#define XXX_STRINGIZE(x) XXX_STRINGIZEX(x)
#define XXX_VSTRINGIZE(...) XXX_VSTRINGIZE_TUPLE((__VA_ARGS__))
#define XXX_CAST_TO_VOID_ELEMENT(r,data,elem) (void)(elem);
#define XXX_CAST_TO_VOID_INTERNAL(TUPLE) XXX_TUPLE_FOR_EACH(XXX_CAST_TO_VOID_ELEMENT,,TUPLE)    
#define XXX_CAST_TO_VOID(...) XXX_CAST_TO_VOID_INTERNAL((__VA_ARGS__))
#define XXX_ENUM_EXTRACT_SP(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en) = BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),1,en)
#define XXX_ENUM_ELEMENT(r,data,elem) BOOST_PP_IF( XXX_TUPLE_SIZE(elem), XXX_ENUM_EXTRACT_SP(elem), elem) ,
#define XXX_ENUM_EXTRACT_ELEMENT(en) BOOST_PP_TUPLE_ELEM(XXX_TUPLE_SIZE(en),0,en)
#define XXX_ENUM_CASE_ELEMENT(en) BOOST_PP_IF( XXX_TUPLE_SIZE(en), XXX_ENUM_EXTRACT_ELEMENT(en), en )
#define XXX_ENUM_CASE(r,data,elem) case data :: XXX_ENUM_CASE_ELEMENT(elem) : return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem));
#define XXX_ENUM_IFELSE(r,data,elem) else if( en == data :: XXX_ENUM_CASE_ELEMENT(elem)) { return #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)); }
#define XXX_ENUM_CASTLIST(r,data,elem) { XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },
#define XXX_ENUM_QUALIFIED_CASTLIST(r,data,elem) { #data "::" XXX_STRINGIZE(XXX_ENUM_CASE_ELEMENT(elem)), data :: XXX_ENUM_CASE_ELEMENT(elem) },

#define XXX_ENUM_INTERNAL(TYPE,NAME,TUPLE)                       \
enum TYPE                                                        \
{                                                                \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_ELEMENT,,TUPLE)                   \
   BOOST_PP_CAT(last_enum_,NAME)                                 \
};                                                               \
                                                                 \
inline                                                           \
const char* to_string( NAME en )                                 \
{                                                                \
   if(false)                                                     \
   {                                                             \
   }                                                             \
   XXX_TUPLE_FOR_EACH(XXX_ENUM_IFELSE,NAME,TUPLE)                \
   else if( en == NAME :: BOOST_PP_CAT(last_enum_,NAME) )        \
   {                                                             \
     return XXX_VSTRINGIZE(NAME,::,BOOST_PP_CAT(last_enum_,NAME));  \
   }                                                             \
   else                                                          \
   {                                                             \
     return "Invalid enum value specified for " # NAME;          \
   }                                                             \
}                                                                \
                                                                 \
inline                                                           \
std::ostream& operator<<( std::ostream& os, const NAME& en )     \
{                                                                \
   os << to_string(en);                                          \
   return os;                                                    \
}                                                                \
                                                                 \
inline                                                           \
NAME do_enum_cast( const std::string& s, const ::xxx::enum_cast_adl_helper<NAME>& ) \
{                                                                \
  static const std::unordered_map<std::string,NAME> map =        \
  {                                                              \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_CASTLIST,NAME,TUPLE)             \
    XXX_TUPLE_FOR_EACH(XXX_ENUM_QUALIFIED_CASTLIST,NAME,TUPLE)   \
  };                                                             \
                                                                 \
  auto cit = map.find(s);                                        \
  if( cit == map.end() )                                         \
  {                                                              \
    throw std::runtime_error("Invalid value to cast to enum");   \
  }                                                              \
  return cit->second;                                            \
}

#define XXX_ENUM(NAME,TUPLE) XXX_ENUM_INTERNAL(NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS(NAME,TUPLE) XXX_ENUM_INTERNAL(class NAME,NAME,TUPLE)
#define XXX_ENUM_CLASS_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(class NAME : TYPE,NAME,TUPLE)
#define XXX_ENUM_TYPE(NAME,TYPE,TUPLE) XXX_ENUM_INTERNAL(NAME : TYPE,NAME,TUPLE)

Nutzung

#include "xxx_enum.h"  //the above lib
#include <iostream>

XXX_ENUM(foo,(a,b,(c,42)));

int main()
{
  std::cout << "foo::a = "            << foo::a            <<'\n';
  std::cout << "(int)foo::c = "       << (int)foo::c       <<'\n';
  std::cout << "to_string(foo::b) = " << to_string(foo::b) <<'\n';
  std::cout << "xxx::enum_cast<foo>(\"b\") = " << xxx::enum_cast<foo>("b") <<'\n';
}

Zusammenstellung (kopieren-einfügen-Kopfzeile im `main.cpp`)

> g++ --version | sed 1q
g++ (GCC) 4.9.2

> g++ -std=c++14 -pedantic -Wall -Wextra main.cpp
main.cpp:268:31: warning: extra ';' [-Wpedantic]
     XXX_ENUM(foo,(a,b,(c,42)));
                               ^

- Ausgang

foo::a = foo::a
(int)foo::c = 42
to_string(foo::b) = foo::b
xxx::enum_cast<foo>("b") = foo::b

InformationsquelleAutor der Antwort PlasmaHH

Generieren Sie einfach Ihren Enumerationen. Schreiben Sie einen generator für diesen Zweck ist etwa fünf Minuten zu arbeiten.

Code Generator in java und python, super einfache Portierung auf beliebige Sprachen, z.B. C++.

Auch super einfach zu verlängern, was auch immer die Funktionalität, die Sie wollen.

Beispiel Eingabe:

First = 5
Second
Third = 7
Fourth
Fifth=11

generierte header:

#include <iosfwd>

enum class Hallo
{
    First = 5,
    Second = 6,
    Third = 7,
    Fourth = 8,
    Fifth = 11
};

std::ostream & operator << (std::ostream &, const Hallo&);

generiert cpp-Datei

#include <ostream>

#include "Hallo.h"

std::ostream & operator << (std::ostream &out, const Hallo&value)
{
    switch(value)
    {
    case Hallo::First:
        out << "First";
        break;
    case Hallo::Second:
        out << "Second";
        break;
    case Hallo::Third:
        out << "Third";
        break;
    case Hallo::Fourth:
        out << "Fourth";
        break;
    case Hallo::Fifth:
        out << "Fifth";
        break;
    default:
        out << "<unknown>";
    }

    return out;
}

Und der generator in einer sehr knappen form als Vorlage für die Portierung und Erweiterung. Dieser Beispiel-code wirklich versucht, zu vermeiden, das überschreiben von Dateien, aber immer noch verwenden Sie es auf Ihr eigenes Risiko.

package cppgen;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class EnumGenerator
{
    static void fail(String message)
    {
        System.err.println(message);
        System.exit(1);
    }

    static void run(String[] args)
    throws Exception
    {
        Pattern pattern = Pattern.compile("\\s*(\\w+)\\s*(?:=\\s*(\\d+))?\\s*", Pattern.UNICODE_CHARACTER_CLASS);
        Charset charset = Charset.forName("UTF8");
        String tab = "    ";

        if (args.length != 3)
        {
            fail("Required arguments: <enum name> <input file> <output dir>");
        }

        String enumName = args[0];

        File inputFile = new File(args[1]);

        if (inputFile.isFile() == false)
        {
            fail("Not a file: [" + inputFile.getCanonicalPath() + "]");
        }

        File outputDir = new File(args[2]);

        if (outputDir.isDirectory() == false)
        {
            fail("Not a directory: [" + outputDir.getCanonicalPath() + "]");
        }

        File headerFile = new File(outputDir, enumName + ".h");
        File codeFile = new File(outputDir, enumName + ".cpp");

        for (File file : new File[] { headerFile, codeFile })
        {
            if (file.exists())
            {
                fail("Will not overwrite file [" + file.getCanonicalPath() + "]");
            }
        }

        int nextValue = 0;

        Map<String, Integer> fields = new LinkedHashMap<>();

        try
        (
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputFile), charset));
        )
        {
            while (true)
            {
                String line = reader.readLine();

                if (line == null)
                {
                    break;
                }

                if (line.trim().length() == 0)
                {
                    continue;
                }

                Matcher matcher = pattern.matcher(line);

                if (matcher.matches() == false)
                {
                    fail("Syntax error: [" + line + "]");
                }

                String fieldName = matcher.group(1);

                if (fields.containsKey(fieldName))
                {
                    fail("Double fiend name: " + fieldName);
                }

                String valueString = matcher.group(2);

                if (valueString != null)
                {
                    int value = Integer.parseInt(valueString);

                    if (value < nextValue)
                    {
                        fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName);
                    }

                    nextValue = value;
                }

                fields.put(fieldName, nextValue);

                ++nextValue;
            }
        }

        try
        (
            PrintWriter headerWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(headerFile), charset));
            PrintWriter codeWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(codeFile), charset));
        )
        {
            headerWriter.println();
            headerWriter.println("#include <iosfwd>");
            headerWriter.println();
            headerWriter.println("enum class " + enumName);
            headerWriter.println('{');
            boolean first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                if (first == false)
                {
                    headerWriter.println(",");
                }

                headerWriter.print(tab + entry.getKey() + " = " + entry.getValue());

                first = false;
            }
            if (first == false)
            {
                headerWriter.println();
            }
            headerWriter.println("};");
            headerWriter.println();
            headerWriter.println("std::ostream & operator << (std::ostream &, const " + enumName + "&);");
            headerWriter.println();

            codeWriter.println();
            codeWriter.println("#include <ostream>");
            codeWriter.println();
            codeWriter.println("#include \"" + enumName + ".h\"");
            codeWriter.println();
            codeWriter.println("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)");
            codeWriter.println('{');
            codeWriter.println(tab + "switch(value)");
            codeWriter.println(tab + '{');
            first = true;
            for (Entry<String, Integer> entry : fields.entrySet())
            {
                codeWriter.println(tab + "case " + enumName + "::" + entry.getKey() + ':');
                codeWriter.println(tab + tab + "out << \"" + entry.getKey() + "\";");
                codeWriter.println(tab + tab + "break;");

                first = false;
            }
            codeWriter.println(tab + "default:");
            codeWriter.println(tab + tab + "out << \"<unknown>\";");
            codeWriter.println(tab + '}');
            codeWriter.println();
            codeWriter.println(tab + "return out;");
            codeWriter.println('}');
            codeWriter.println();
        }
    }

    public static void main(String[] args)
    {
        try
        {
            run(args);
        }
        catch(Exception exc)
        {
            exc.printStackTrace();
            System.exit(1);
        }
    }
}

Sowie einen port für Python-3.5 da unterschiedliche genug, um potenziell hilfreich

import re
import collections
import sys
import io
import os

def fail(*args):
    print(*args)
    exit(1)

pattern = re.compile(r'\s*(\w+)\s*(?:=\s*(\d+))?\s*')
tab = "    "

if len(sys.argv) != 4:
    n=0
    for arg in sys.argv:
        print("arg", n, ":", arg, " /", sys.argv[n])
        n += 1
    fail("Required arguments: <enum name> <input file> <output dir>")

enumName = sys.argv[1]

inputFile = sys.argv[2]

if not os.path.isfile(inputFile):
    fail("Not a file: [" + os.path.abspath(inputFile) + "]")

outputDir = sys.argv[3]

if not os.path.isdir(outputDir):
    fail("Not a directory: [" + os.path.abspath(outputDir) + "]")

headerFile = os.path.join(outputDir, enumName + ".h")
codeFile = os.path.join(outputDir, enumName + ".cpp")

for file in [ headerFile, codeFile ]:
    if os.path.exists(file):
        fail("Will not overwrite file [" + os.path.abspath(file) + "]")

nextValue = 0

fields = collections.OrderedDict()

for line in open(inputFile, 'r'):
    line = line.strip()

    if len(line) == 0:
        continue

    match = pattern.match(line)

    if match == None:
        fail("Syntax error: [" + line + "]")

    fieldName = match.group(1)

    if fieldName in fields:
        fail("Double field name: " + fieldName)

    valueString = match.group(2)

    if valueString != None:
        value = int(valueString)

        if value < nextValue:
            fail("Not a monotonous progression from " + nextValue + " to " + value + " for enum field " + fieldName)

        nextValue = value

    fields[fieldName] = nextValue

    nextValue += 1

headerWriter = open(headerFile, 'w')
codeWriter = open(codeFile, 'w')

try:
    headerWriter.write("\n")
    headerWriter.write("#include <iosfwd>\n")
    headerWriter.write("\n")
    headerWriter.write("enum class " + enumName + "\n")
    headerWriter.write("{\n")
    first = True
    for fieldName, fieldValue in fields.items():
        if not first:
            headerWriter.write(",\n")

        headerWriter.write(tab + fieldName + " = " + str(fieldValue))

        first = False
    if not first:
        headerWriter.write("\n")
    headerWriter.write("};\n")
    headerWriter.write("\n")
    headerWriter.write("std::ostream & operator << (std::ostream &, const " + enumName + "&);\n")
    headerWriter.write("\n")

    codeWriter.write("\n")
    codeWriter.write("#include <ostream>\n")
    codeWriter.write("\n")
    codeWriter.write("#include \"" + enumName + ".h\"\n")
    codeWriter.write("\n")
    codeWriter.write("std::ostream & operator << (std::ostream &out, const " + enumName + "&value)\n")
    codeWriter.write("{\n")
    codeWriter.write(tab + "switch(value)\n")
    codeWriter.write(tab + "{\n")
    for fieldName in fields.keys():
        codeWriter.write(tab + "case " + enumName + "::" + fieldName + ":\n")
        codeWriter.write(tab + tab + "out << \"" + fieldName + "\";\n")
        codeWriter.write(tab + tab + "break;\n")
    codeWriter.write(tab + "default:\n")
    codeWriter.write(tab + tab + "out << \"<unknown>\";\n")
    codeWriter.write(tab + "}\n")
    codeWriter.write("\n")
    codeWriter.write(tab + "return out;\n")
    codeWriter.write("}\n")
    codeWriter.write("\n")
finally:
    headerWriter.close()
    codeWriter.close()

InformationsquelleAutor der Antwort yeoman

Nahm ich die Idee von @antron und implementiert es anders: Erzeugung einer echten enum-Klasse.

Diese Implementierung erfüllt alle Anforderungen aufgelistet in der ursprünglichen Frage, aber derzeit hat nur ein wirkliche Einschränkung: es übernimmt die enum-Werte sind entweder nicht vorhanden oder, wenn vorhanden, muss starten bei 0 und gehen bis sequentiell ohne Lücken.

Dies ist nicht eine immanente Beschränkung - einfach, ich benutze keine ad-hoc-enum-Werte. Wenn dies erforderlich ist, kann man ersetzen Vektor-lookup mit traditionellen switch - /case-Umsetzung.

Die Lösung nutzt eine c++17 für inline-Variablen, aber dies kann leicht vermieden werden, wenn nötig. Es nutzt auch boost:trim wegen der Einfachheit.

Am wichtigsten ist, dauert es nur 30 Zeilen code und keine schwarze Magie Makros.
Der code ist unten. Es soll gesetzt werden, im header und in mehreren compilation-Module.

Kann es verwendet werden, die gleiche Weise wie zuvor in diesem thread:

ENUM(Channel, int, Red, Green = 1, Blue)
std::out << "My name is " << Channel::Green;
//prints My name is Green

Pls lassen Sie mich wissen, wenn dies sinnvoll ist und wie es weiter verbessert werden kann.

#include <boost/algorithm/string.hpp>   
struct EnumSupportBase {
  static std::vector<std::string> split(const std::string s, char delim) {
    std::stringstream ss(s);
    std::string item;
    std::vector<std::string> tokens;
    while (std::getline(ss, item, delim)) {
        auto pos = item.find_first_of ('=');
        if (pos != std::string::npos)
            item.erase (pos);
        boost::trim (item);
        tokens.push_back(item);
    }
    return tokens;
  }
};
#define ENUM(EnumName, Underlying, ...) \
    enum class EnumName : Underlying { __VA_ARGS__, _count }; \
    struct EnumName ## Support : EnumSupportBase { \
        static inline std::vector<std::string> _token_names = split(#__VA_ARGS__, ','); \
        static constexpr const char* get_name(EnumName enum_value) { \
            int index = (int)enum_value; \
            if (index >= (int)EnumName::_count || index < 0) \
               return "???"; \
            else \
               return _token_names[index].c_str(); \
        } \
    }; \
    inline std::ostream& operator<<(std::ostream& os, const EnumName & es) { \
        return os << EnumName##Support::get_name(es); \
    }

InformationsquelleAutor der Antwort Yuri Finkelstein

Folgende Lösung basiert auf einer std::array<std::string,N> für eine bestimmte enum.

Für enum zu std::string Umstellung können wir nur werfen die enum zu size_t und Suche den string aus dem array. Die operation ist O(1) und erfordert keine heap.

#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/stringize.hpp>

#include <string>
#include <array>
#include <iostream>

#define STRINGIZE(s, data, elem) BOOST_PP_STRINGIZE(elem)

//ENUM
//============================================================================
#define ENUM(X, SEQ) \
struct X {   \
    enum Enum {BOOST_PP_SEQ_ENUM(SEQ)}; \
    static const std::array<std::string,BOOST_PP_SEQ_SIZE(SEQ)> array_of_strings() { \
        return {{BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(STRINGIZE, 0, SEQ))}}; \
    } \
    static std::string to_string(Enum e) { \
        auto a = array_of_strings(); \
        return a[static_cast<size_t>(e)]; \
    } \
}

Für std::string zu enum Bekehrung, die wir haben würden, um eine lineare Suche über das Feld und warf den array-index zu enum.

Versuchen Sie es hier mit Syntax-Beispiele: http://coliru.stacked-crooked.com/a/e4212f93bee65076

Edit: überarbeitung meiner Lösung, so dass die benutzerdefinierten Enum können innerhalb einer Klasse verwendet werden.

InformationsquelleAutor der Antwort FKaria

Lösungen mit enum innerhalb der Klasse/struct (struct standardmäßig mit öffentlichen Mitglieder) und das überladen von Operatoren:

struct Color
{
    enum Enum { RED, GREEN, BLUE };
    Enum e;

    Color() {}
    Color(Enum e) : e(e) {}

    Color operator=(Enum o) { e = o; return *this; }
    Color operator=(Color o) { e = o.e; return *this; }
    bool operator==(Enum o) { return e == o; }
    bool operator==(Color o) { return e == o.e; }
    operator Enum() const { return e; }

    std::string toString() const
    {
        switch (e)
        {
        case Color::RED:
            return "red";
        case Color::GREEN:
            return "green";
        case Color::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
};

Von außen sieht es fast genau so wie ein Klasse enum:

Color red;
red = Color::RED;
Color blue = Color::BLUE;

cout << red.toString() << " " << Color::GREEN << " " << blue << endl;

Dieser Ausgabe wird "red 1 2". Man könnte vielleicht überlastung << blau-Ausgabe ein string (obwohl es könnte dazu führen Mehrdeutigkeit so nicht möglich), aber es würde nicht funktionieren mit Farbe::GRÜN da es nicht automatisch konvertieren Farbe.

Dem Zweck dient, eine implizite konvertieren von Enum (die implizit konvertiert zu int oder Typ) ist in der Lage sein zu tun:

Color color;
switch (color) ...

Dies funktioniert, aber es bedeutet auch, dass diese Arbeit auch:

int i = color;

Mit einer enum-Klasse, es würde nicht kompilieren.
Sie sollten vorsichtig sein, wenn Sie überlastung beiden Funktionen unter dem enum und integer, oder entfernen Sie die implizite Konvertierung...

Andere Lösung würde bedeuten, mit einer tatsächlichen enum-Klasse und static-member:

struct Color
{
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    //same as previous...
};

Es möglicherweise mehr Platz in Anspruch nimmt, und ist mehr zu machen, sondern führt zu einem Kompilierfehler für implizite int-Konvertierungen. Ich würde diese benutzen!

Es ist sicherlich Aufwand mit dieser, obwohl, aber ich denke, es ist nur einfacher und sieht besser aus als andere code, den ich gesehen habe. Es gibt auch Potenzial für das hinzufügen von Funktionalität, die alle eingeschränkt werden innerhalb der Klasse.

Bearbeiten: das funktioniert und die meisten werden vor der Ausführung kompiliert:

class Color
{
public:
    enum class Enum { RED, GREEN, BLUE };
    static const Enum RED = Enum::RED, GREEN = Enum::GREEN, BLUE = Enum::BLUE;

    constexpr Color() : e(Enum::RED) {}
    constexpr Color(Enum e) : e(e) {}

    constexpr bool operator==(Enum o) const { return e == o; }
    constexpr bool operator==(Color o) const { return e == o.e; }
    constexpr operator Enum() const { return e; }

    Color& operator=(Enum o) { const_cast<Enum>(this->e) = o; return *this; }
    Color& operator=(Color o) { const_cast<Enum>(this->e) = o.e; return *this; }

    std::string toString() const
    {
        switch (e)
        {
        case Enum::RED:
            return "red";
        case Enum::GREEN:
            return "green";
        case Enum::BLUE:
            return "blue";
        default:
            return "unknown";
        }
    }
private:
    const Enum e;
};

InformationsquelleAutor der Antwort Pat-Laugh

Diese gist bietet eine einfache Zuordnung basierend auf C++ variadic-Vorlagen.

Dies ist ein C++ - 17-vereinfachte version des Typ-basierte Karte aus dem gist:

#include <cstring> //http://stackoverflow.com/q/24520781

template<typename KeyValue, typename ... RestOfKeyValues>
struct map {
  static constexpr typename KeyValue::key_t get(const char* val) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)  //C++17 if constexpr
      return KeyValue::key; //Returns last element
    else {
      static_assert(KeyValue::val != nullptr,
                  "Only last element may have null name");
      return strcmp(val, KeyValue::val()) 
            ? map<RestOfKeyValues...>::get(val) : KeyValue::key;
    }
  }
  static constexpr const char* get(typename KeyValue::key_t key) noexcept {
    if constexpr (sizeof...(RestOfKeyValues)==0)
      return (KeyValue::val != nullptr) && (key == KeyValue::key)
            ? KeyValue::val() : "";
    else
      return (key == KeyValue::key) 
            ? KeyValue::val() : map<RestOfKeyValues...>::get(key);
  }
};

template<typename Enum, typename ... KeyValues>
class names {
  typedef map<KeyValues...> Map;
public:
  static constexpr Enum get(const char* nam) noexcept {
    return Map::get(nam);
  }
  static constexpr const char* get(Enum key) noexcept {
    return Map::get(key);
  }
};

Beispiel:

enum class fasion {
    fancy,
    classic,
    sporty,
    emo,
    __last__ = emo,
    __unknown__ = -1
};

#define NAME(s) static inline constexpr const char* s() noexcept {return #s;}
namespace name {
    NAME(fancy)
    NAME(classic)
    NAME(sporty)
    NAME(emo)
}

template<auto K, const char* (*V)()>  //C++17 template<auto>
struct _ {
    typedef decltype(K) key_t;
    typedef decltype(V) name_t;
    static constexpr key_t  key = K; //enum id value
    static constexpr name_t val = V; //enum id name
};

typedef names<fasion,
    _<fasion::fancy, name::fancy>,
    _<fasion::classic, name::classic>,
    _<fasion::sporty, name::sporty>,
    _<fasion::emo, name::emo>,
    _<fasion::__unknown__, nullptr>
> fasion_names;

Den map<KeyValues...> kann in beiden Richtungen verwendet werden:

fasion_names::get(fasion::emo)
fasion_names::get("emo")

Diesem Beispiel ist auf godbolt.org

int main ()
{
  constexpr auto str = fasion_names::get(fasion::emo);
  constexpr auto fsn = fasion_names::get(str);
  return (int) fsn;
}

Ergebnis von gcc-7 -std=c++1z -Ofast -S

main:
        mov     eax, 3
        ret

InformationsquelleAutor der Antwort hutorny

Sehr einfache Lösung mit einer großen Einschränkung: Sie können nicht zuweisen einer benutzerdefinierten Werte zu enum Werte, aber mit den richtigen regex könnte man. man könnte auch hinzufügen, eine Karte zu übersetzen, zurück zu enum Werte ohne viel Aufwand:

#include <vector>
#include <string>
#include <regex>
#include <iterator>

std::vector<std::string> split(const std::string& s, 
                               const std::regex& delim = std::regex(",\\s*"))
{
    using namespace std;
    vector<string> cont;
    copy(regex_token_iterator<string::const_iterator>(s.begin(), s.end(), delim, -1), 
         regex_token_iterator<string::const_iterator>(),
         back_inserter(cont));
    return cont;
}

#define EnumType(Type, ...)     enum class Type { __VA_ARGS__ }

#define EnumStrings(Type, ...)  static const std::vector<std::string> \
                                Type##Strings = split(#__VA_ARGS__);

#define EnumToString(Type, ...) EnumType(Type, __VA_ARGS__); \
                                EnumStrings(Type, __VA_ARGS__)

Beispiel:

EnumToString(MyEnum, Red, Green, Blue);

InformationsquelleAutor der Antwort malem

Ich war frustriert über dieses problem für eine lange Zeit auch, zusammen mit dem problem der immer ein Typ in eine Zeichenfolge konvertiert, die in einem richtigen Weg. Jedoch für das Letzte problem, ich war überrascht von der Lösung erklärt Ist es möglich, drucken Sie die variable Typ in der standard-C++?mit der Idee von Bekomme ich C++ - Typ-Namen in einer constexpr Weg?. Mit dieser Technik wird eine analoge Funktion konstruiert werden kann für immer eine enum-Wert als string:

#include <iostream>
using namespace std;

class static_string
{
    const char* const p_;
    const std::size_t sz_;

public:
    typedef const char* const_iterator;

    template <std::size_t N>
    constexpr static_string(const char(&a)[N]) noexcept
        : p_(a)
        , sz_(N - 1)
    {}

    constexpr static_string(const char* p, std::size_t N) noexcept
        : p_(p)
        , sz_(N)
    {}

    constexpr const char* data() const noexcept { return p_; }
    constexpr std::size_t size() const noexcept { return sz_; }

    constexpr const_iterator begin() const noexcept { return p_; }
    constexpr const_iterator end()   const noexcept { return p_ + sz_; }

    constexpr char operator[](std::size_t n) const
    {
        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
    }
};

inline std::ostream& operator<<(std::ostream& os, static_string const& s)
{
    return os.write(s.data(), s.size());
}

///\brief Get the name of a type
template <class T>
static_string typeName()
{
#ifdef __clang__
    static_string p = __PRETTY_FUNCTION__;
    return static_string(p.data() + 30, p.size() - 30 - 1);
#elif defined(_MSC_VER)
    static_string p = __FUNCSIG__;
    return static_string(p.data() + 37, p.size() - 37 - 7);
#endif

}

namespace details
{
    template <class Enum>
    struct EnumWrapper
    {
        template < Enum enu >
        static static_string name()
        {
#ifdef __clang__
            static_string p = __PRETTY_FUNCTION__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 73 + enumType.size(), p.size() - 73 - enumType.size() - 1);
#elif defined(_MSC_VER)
            static_string p = __FUNCSIG__;
            static_string enumType = typeName<Enum>();
            return static_string(p.data() + 57 + enumType.size(), p.size() - 57 - enumType.size() - 7);
#endif
        }
    };
}

///\brief Get the name of an enum value
template <typename Enum, Enum enu>
static_string enumName()
{
    return details::EnumWrapper<Enum>::template name<enu>();
}

enum class Color
{
    Blue = 0,
    Yellow = 1
};


int main() 
{
    std::cout << "_" << typeName<Color>() << "_"  << std::endl;
    std::cout << "_" << enumName<Color, Color::Blue>() << "_"  << std::endl;
    return 0;
}

Den code oben wurde nur getestet auf Clang (siehe https://ideone.com/je5Quv) und VS2015, sollte aber anpassbar sein, um auch andere Compiler durch Experimentieren ein bisschen mit der integer-Konstanten. Natürlich, es noch Makros verwendet unter der Haube, aber zumindest braucht man keine Zugriff auf die enum-Umsetzung.

InformationsquelleAutor der Antwort Ignace

BEARBEITEN: überprüfen Sie unten für eine neuere version

Wie oben erwähnt, N4113 ist die endgültige Lösung dieser Angelegenheit, aber wir müssen warten mehr als a Jahr, um zu sehen, es kommt.

Inzwischen, wenn Sie wollen, dass diese Funktion, müssen Sie greifen, um "einfache" Vorlagen und einige Präprozessor-Magie.

Enumerator

template<typename T>
class Enum final
{
    const char* m_name;
    const T m_value;
    static T m_counter;

public:
    Enum(const char* str, T init = m_counter) : m_name(str), m_value(init) {m_counter = (init + 1);}

    const T value() const {return m_value;}
    const char* name() const {return m_name;}
};

template<typename T>
T Enum<T>::m_counter = 0;

#define ENUM_TYPE(x)      using Enum = Enum<x>;
#define ENUM_DECL(x,...)  x(#x,##__VA_ARGS__)
#define ENUM(...)         const Enum ENUM_DECL(__VA_ARGS__);

Nutzung

#include <iostream>

//the initialization order should be correct in all scenarios
namespace Level
{
    ENUM_TYPE(std::uint8)
    ENUM(OFF)
    ENUM(SEVERE)
    ENUM(WARNING)
    ENUM(INFO, 10)
    ENUM(DEBUG)
    ENUM(ALL)
}

namespace Example
{
    ENUM_TYPE(long)
    ENUM(A)
    ENUM(B)
    ENUM(C, 20)
    ENUM(D)
    ENUM(E)
    ENUM(F)
}

int main(int argc, char** argv)
{
    Level::Enum lvl = Level::WARNING;
    Example::Enum ex = Example::C;
    std::cout << lvl.value() << std::endl; //2
    std::cout << ex.value() << std::endl; //20
}

Einfache Erklärung

Enum<T>::m_counter auf 0 gesetzt ist in jedem namespace-Deklaration.

(Könnte mir jemand zeigen heraus, wo ^^dieses Verhalten^^ erwähnt wird, die auf dem standard?)

Die Präprozessor-Magie automatisiert die Erklärung von Enumeratoren.

Nachteile

Es ist nicht eine echte enum geben, daher nicht promotable int
Verwendet werden kann-switch Fällen

Alternative Lösung

Diese ein Opfer der Zeilennummerierung (nicht wirklich) kann aber verwendet werden, auf switch Fällen.

#define ENUM_TYPE(x) using type = Enum<x>
#define ENUM(x)      constexpr type x{__LINE__,#x}

template<typename T>
struct Enum final
{
    const T value;
    const char* name;

    constexpr operator const T() const noexcept {return value;}
    constexpr const char* operator&() const noexcept {return name;}
};

Errata

#line 0 Konflikte mit -pedantic auf GCC und clang.

Abhilfe

Starten Sie entweder bei #line 1 und subtrahieren Sie 1 von __LINE__.

Oder, nicht verwenden -pedantic.

Und wenn wir schon dabei sind, vermeiden VC++ unter allen Umständen, es war schon immer ein Witz von einem compiler.

Nutzung

#include <iostream>

namespace Level
{
    ENUM_TYPE(short);
    #line 0
    ENUM(OFF);
    ENUM(SEVERE);
    ENUM(WARNING);
    #line 10
    ENUM(INFO);
    ENUM(DEBUG);
    ENUM(ALL);
    #line <next line number> //restore the line numbering
};

int main(int argc, char** argv)
{
    std::cout << Level::OFF << std::endl;   //0
    std::cout << &Level::OFF << std::endl;  //OFF

    std::cout << Level::INFO << std::endl;  //10
    std::cout << &Level::INFO << std::endl; //INFO

    switch(/* any integer or integer-convertible type */)
    {
    case Level::OFF:
        //...
        break;

    case Level::SEVERE:
        //...
        break;

    //...
    }

    return 0;
}

Real-life-Umsetzung und Verwendung

r3dVoxel - Enum

r3dVoxel - ELoggingLevel

Kurzanleitung

#Zeile lineno -- cppreference.com

InformationsquelleAutor der Antwort bit2shift

Solange Sie in Ordnung sind, mit schriftlich eine separate .h/.cpp paar für jeden queryable enum, diese Lösung funktioniert mit fast den gleichen syntax und Funktionen wie eine normale c++ - enum:

//MyEnum.h
#include <EnumTraits.h>
#ifndef ENUM_INCLUDE_MULTI
#pragma once
#end if

enum MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = AAA + BBB
};

Den .cpp Datei 3 Zeilen boilerplate:

//MyEnum.cpp
#define ENUM_DEFINE MyEnum
#define ENUM_INCLUDE <MyEnum.h>
#include <EnumTraits.inl>

Beispiel:

for (MyEnum value : EnumTraits<MyEnum>::GetValues())
    std::cout << EnumTraits<MyEnum>::GetName(value) << std::endl;

Code

Diese Lösung erfordert 2 source-Dateien:

//EnumTraits.h
#pragma once
#include <string>
#include <unordered_map>
#include <vector>

#define ETRAITS
#define EDECL(x) x

template <class ENUM>
class EnumTraits
{
public:
    static const std::vector<ENUM>& GetValues()
    {
        return values;
    }

    static ENUM GetValue(const char* name)
    {
        auto match = valueMap.find(name);
        return (match == valueMap.end() ? ENUM() : match->second);
    }

    static const char* GetName(ENUM value)
    {
        auto match = nameMap.find(value);
        return (match == nameMap.end() ? nullptr : match->second);
    }

public:
    EnumTraits() = delete;

    using vector_type = std::vector<ENUM>;
    using name_map_type = std::unordered_map<ENUM, const char*>;
    using value_map_type = std::unordered_map<std::string, ENUM>;

private:
    static const vector_type values;
    static const name_map_type nameMap;
    static const value_map_type valueMap;
};

struct EnumInitGuard{ constexpr const EnumInitGuard& operator=(int) const { return *this; } };
template <class T> constexpr T& operator<<=(T&& x, const EnumInitGuard&) { return x; }

...und

//EnumTraits.inl
#define ENUM_INCLUDE_MULTI

#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

using EnumType = ENUM_DEFINE;
using TraitsType = EnumTraits<EnumType>;
using VectorType = typename TraitsType::vector_type;
using NameMapType = typename TraitsType::name_map_type;
using ValueMapType = typename TraitsType::value_map_type;
using NamePairType = typename NameMapType::value_type;
using ValuePairType = typename ValueMapType::value_type;

#define ETRAITS ; const VectorType TraitsType::values
#define EDECL(x) EnumType::x <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const NameMapType TraitsType::nameMap
#define EDECL(x) NamePairType(EnumType::x, #x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

#define ETRAITS ; const ValueMapType TraitsType::valueMap
#define EDECL(x) ValuePairType(#x, EnumType::x) <<= EnumInitGuard()
#include ENUM_INCLUDE
#undef ETRAITS
#undef EDECL

Erklärung

Diese Implementierung nutzt die Tatsache, dass die verspannt Liste von Elementen einer enum-definition kann auch verwendet werden, als eine verspannte Initialisierungsliste für die Klasse Mitglied der Initialisierung.

Wenn ETRAITS wird ausgewertet im Kontext der EnumTraits.inl
es baut sich eine statische member-definition für die EnumTraits<> Klasse.

Den EDECL makro wandelt jede enum-Mitglied in Initialisierer-Liste-Werte, die anschließend übergeben bekommen in den Mitglied-Konstruktor, um zu füllen Sie die enum-info.

Den EnumInitGuard Klasse ist entworfen, um zu konsumieren, die enum-Initialisierung-Werte und dann zusammenbrechen und hinterlässt eine Reine Liste von enum-Daten.

Vorteile

c++-ähnliche syntax
Funktioniert identisch für beide enum und enum class (fast*)
Werke für enum Typen mit beliebiger numerischer zugrunde liegenden Typ
Werke für enum Typen mit automatic, explicit und fragmentiert Initialisierer Werte
Werke für die Massen-Umbenennung (intellisense-Verknüpfung erhalten)
Nur 5 Präprozessor-Symbole (3 Globale)

* Im Gegensatz zu enumsInitialisierungen in enum class Typen, die Verweise auf andere Werte, die von den gleichen enum müssen diese Werte voll qualifizierte

Disbenefits

Erfordert eine separate .h/.cpp paar für jeden queryable enum
Hängt davon ab, gewundenen macro und include Magie
Kleinere Fehler in der syntax explodieren in viel größeren Fehler
Definieren class oder namespace scoped enums nicht trivial ist,
Keine compile-Zeit-Initialisierung

Kommentare

Intellisense wird sich beschweren, ein bisschen über die privaten member zugreifen, wenn die öffnung EnumTraits.inlaber da die expandierten Makros eigentlich sind, definieren Sie die Schüler, das ist nicht wirklich ein problem.

Den #ifndef ENUM_INCLUDE_MULTI block an der Spitze der header-Datei ist eine geringfügige ärgernis, dass könnte wahrscheinlich werden geschrumpft nach unten in ein makro oder so, aber es ist klein genug, um mit zu Leben in der aktuellen Größe.

Deklarieren einen namespace scoped enum erfordert, dass die enum-erste vorwärts erklärt im namespace-Gültigkeitsbereich, dann definiert in den globalen Namensraum. Darüber hinaus wird jeder enum-Initialisierungen mit den Werten der gleichen enum müssen diese Werte voll qualifizierte.

namespace ns { enum MyEnum : int; }
enum ns::MyEnum : int ETRAITS
{
    EDECL(AAA) = -8,
    EDECL(BBB) = '8',
    EDECL(CCC) = ns::MyEnum::AAA + ns::MyEnum::BBB
}

InformationsquelleAutor der Antwort Jason Lim

0

Schrieb ich eine Bibliothek für die Lösung des Problems, alles geschieht zu kompilieren, außer für die Meldung bekommen.

Verwendung:

Makro benutzen DEF_MSG zum definieren einer makro-und message-pair-Mädchen:
```
DEF_MSG(CODE_OK,   "OK!")
DEF_MSG(CODE_FAIL, "Fail!")
```
CODE_OK ist das makro zu verwenden, und "OK!" ist die entsprechende Nachricht.

Verwenden get_message() oder nur gm() die Nachricht bekommen:
```
get_message(CODE_FAIL);  //will return "Fail!"
gm(CODE_FAIL);           //works exactly the same as above
```
Verwenden MSG_NUM um herauszufinden, wie viele Makros definiert wurden. Diese wird automatisch increse, Sie brauchen nicht, etwas zu tun.

Vordefinierte Meldungen:
```
MSG_OK:     OK
MSG_BOTTOM: Message bottom
```
Projekt: libcodemsg

Die Bibliothek erzeugt keine zusätzlichen Daten. Alles passiert bei der Zusammenstellung der Zeit. In message_def.h wird, generiert es eine enum genannt MSG_CODE; in message_def.c es erzeugt eine variable hält alle Fäden in static const char* _g_messages[].

In diesem Fall die Bibliothek ist begrenzt, um eine zu erstellen enum nur. Dies ist ideal für die Werte zurückgeben, zum Beispiel:
```
MSG_CODE foo(void) {
    return MSG_OK; //or something else
}

MSG_CODE ret = foo();

if (MSG_OK != ret) {
    printf("%s\n", gm(ret););
}
```
Andere Sache, ich mag dieses design ist, können Sie verwalten message-Definitionen in verschiedene Dateien.

Fand ich die Lösung zu diese Frage sieht viel besser aus.

InformationsquelleAutor der Antwort Madwyn

#define ENUM_MAKE(TYPE, ...) \
        enum class TYPE {__VA_ARGS__};\
        struct Helper_ ## TYPE { \
            static const String& toName(TYPE type) {\
                int index = static_cast<int>(type);\
                return splitStringVec()[index];}\
            static const TYPE toType(const String& name){\
                static std::unordered_map<String,TYPE> typeNameMap;\
                if( typeNameMap.empty() )\
                {\
                    const StringVector& ssVec = splitStringVec();\
                    for (size_t i = 0; i < ssVec.size(); ++i)\
                        typeNameMap.insert(std::make_pair(ssVec[i], static_cast<TYPE>(i)));\
                }\
                return typeNameMap[name];}\
            static const StringVector& splitStringVec() {\
                static StringVector typeNameVector;\
                if(typeNameVector.empty()) \
                {\
                    typeNameVector = StringUtil::split(#__VA_ARGS__, ",");\
                    for (auto& name : typeNameVector)\
                    {\
                        name.erase(std::remove(name.begin(), name.end(), ' '),name.end()); \
                        name = String(#TYPE) + "::" + name;\
                    }\
                }\
                return typeNameVector;\
            }\
        };


using String = std::string;
using StringVector = std::vector<String>;

   StringVector StringUtil::split( const String& str, const String& delims, unsigned int maxSplits, bool preserveDelims)
    {
        StringVector ret;
        //Pre-allocate some space for performance
        ret.reserve(maxSplits ? maxSplits+1 : 10);    //10 is guessed capacity for most case

        unsigned int numSplits = 0;

        //Use STL methods 
        size_t start, pos;
        start = 0;
        do 
        {
            pos = str.find_first_of(delims, start);
            if (pos == start)
            {
                //Do nothing
                start = pos + 1;
            }
            else if (pos == String::npos || (maxSplits && numSplits == maxSplits))
            {
                //Copy the rest of the string
                ret.push_back( str.substr(start) );
                break;
            }
            else
            {
                //Copy up to delimiter
                ret.push_back( str.substr(start, pos - start) );

                if(preserveDelims)
                {
                    //Sometimes there could be more than one delimiter in a row.
                    //Loop until we don't find any more delims
                    size_t delimStart = pos, delimPos;
                    delimPos = str.find_first_not_of(delims, delimStart);
                    if (delimPos == String::npos)
                    {
                        //Copy the rest of the string
                        ret.push_back( str.substr(delimStart) );
                    }
                    else
                    {
                        ret.push_back( str.substr(delimStart, delimPos - delimStart) );
                    }
                }

                start = pos + 1;
            }
            //parse up to next real data
            start = str.find_first_not_of(delims, start);
            ++numSplits;

        } while (pos != String::npos);



        return ret;
    }

Beispiel

ENUM_MAKE(MY_TEST, MY_1, MY_2, MY_3)


    MY_TEST s1 = MY_TEST::MY_1;
    MY_TEST s2 = MY_TEST::MY_2;
    MY_TEST s3 = MY_TEST::MY_3;

    String z1 = Helper_MY_TEST::toName(s1);
    String z2 = Helper_MY_TEST::toName(s2);
    String z3 = Helper_MY_TEST::toName(s3);

    MY_TEST q1 = Helper_MY_TEST::toType(z1);
    MY_TEST q2 = Helper_MY_TEST::toType(z2);
    MY_TEST q3 = Helper_MY_TEST::toType(z3);

automatisch ENUM_MAKE makro erzeugen 'enum-Klasse' und helper-Klasse mit 'enum-Reflexion-Funktion'.

Zur Reduzierung der Fehler, das auf einmal Alles definiert ist, mit nur einem ENUM_MAKE.

Der Vorteil dieses Codes ist automatisch erstellt, für Reflexion und einen genauen Blick auf makro-code ,einfach-zu-verstehen von code. 'enum zu string' , 'string zu enum' Leistung des Algorithmus ist O(1).

Nachteile ist bei der ersten Verwendung , helper-Klasse für enum-Reflexion 's string-Vektor und die Karte wird initialisiert.
aber Wenn Sie wollen, Sie werden auch vor-initialisiert. –

InformationsquelleAutor der Antwort desperado_98

meine Lösung ist ohne makro-Nutzung.

Vorteile:

Sie sehen genau, was Sie tun
Zugriff mit hash-maps, die so gut für viele geschätzt enums
keine Notwendigkeit zu prüfen oder um nicht-aufeinanderfolgende Werte
beide enum zu string und string zu enum-übersetzung, während die Hinzugefügt enum-Wert muss Hinzugefügt werden, in einem weiteren Ort nur

Nachteile:

müssen Sie replizieren alle Enumerationen, die Werte als text
Zugang in der hash-map berücksichtigen müssen Zeichenfolge Fall
Wartung bei hinzufügen von Werten schmerzhaft ist - muss Hinzugefügt werden, in beiden enum und direkt übersetzen map

so... bis zu dem Tag, dass C++ implementiert, die C# - Enum.Analysieren, Funktionalität, ich hängen werden:

            #include <unordered_map>

            enum class Language
            { unknown, 
                Chinese, 
                English, 
                French, 
                German
                //etc etc
            };

            class Enumerations
            {
            public:
                static void fnInit(void);

                static std::unordered_map <std::wstring, Language> m_Language;
                static std::unordered_map <Language, std::wstring> m_invLanguage;

            private:
                static void fnClear();
                static void fnSetValues(void);
                static void fnInvertValues(void);

                static bool m_init_done;
            };

            std::unordered_map <std::wstring, Language> Enumerations::m_Language = std::unordered_map <std::wstring, Language>();
            std::unordered_map <Language, std::wstring> Enumerations::m_invLanguage = std::unordered_map <Language, std::wstring>();

            void Enumerations::fnInit()
            {
                fnClear();
                fnSetValues();
                fnInvertValues();
            }

            void Enumerations::fnClear()
            {
                m_Language.clear();
                m_invLanguage.clear();
            }

            void Enumerations::fnSetValues(void)
            {   
                m_Language[L"unknown"] = Language::unknown;
                m_Language[L"Chinese"] = Language::Chinese;
                m_Language[L"English"] = Language::English;
                m_Language[L"French"] = Language::French;
                m_Language[L"German"] = Language::German;
                //and more etc etc
            }

            void Enumerations::fnInvertValues(void)
            {
                for (auto it = m_Language.begin(); it != m_Language.end(); it++)
                {
                    m_invLanguage[it->second] = it->first;
                }
            }

            //usage -
            //Language aLanguage = Language::English;
            //wstring sLanguage = Enumerations::m_invLanguage[aLanguage];

            //wstring sLanguage = L"French" ;
            //Language aLanguage = Enumerations::m_Language[sLanguage];

InformationsquelleAutor der Antwort Mia Shani

-1

Gut, noch eine andere option. Ein typischer Anwendungsfall ist, wo Sie müssen Konstanten für die HTTP-Verben als auch mit seinen string-version zu Werten.

Beispiel:

int main () {

  VERB a = VERB::GET;
  VERB b = VERB::GET;
  VERB c = VERB::POST;
  VERB d = VERB::PUT;
  VERB e = VERB::DELETE;


  std::cout << a.toString() << std::endl;

  std::cout << a << std::endl;

  if ( a == VERB::GET ) {
    std::cout << "yes" << std::endl;
  }

  if ( a == b ) {
    std::cout << "yes" << std::endl;
  }

  if ( a != c ) {
    std::cout << "no" << std::endl;
  }

}

Dem VERB Klasse:

//-----------------------------------------------------------
//-----------------------------------------------------------
class VERB {

private:

  //private constants
  enum Verb {GET_=0, POST_, PUT_, DELETE_};

  //private string values
  static const std::string theStrings[];

  //private value
  const Verb value;
  const std::string text;

  //private constructor
  VERB (Verb v) :
  value(v), text (theStrings[v])
  {
    //std::cout << " constructor \n";
  }

public:

  operator const char * ()  const { return text.c_str(); }

  operator const std::string ()  const { return text; }

  const std::string toString () const { return text; }

  bool operator == (const VERB & other) const { return (*this).value == other.value; }

  bool operator != (const VERB & other) const { return ! ( (*this) == other); }

  //---

  static const VERB GET;
  static const VERB POST;
  static const VERB PUT;
  static const VERB DELETE;

};

const std::string VERB::theStrings[] = {"GET", "POST", "PUT", "DELETE"};

const VERB VERB::GET = VERB ( VERB::Verb::GET_ );
const VERB VERB::POST = VERB ( VERB::Verb::POST_ );
const VERB VERB::PUT = VERB ( VERB::Verb::PUT_ );
const VERB VERB::DELETE = VERB ( VERB::Verb::DELETE_ );
//end of file

InformationsquelleAutor der Antwort cibercitizen1

-5

Was über eine einfache streaming-überlastung?
Haben Sie immer noch pflegen Sie die Zuordnung, wenn Sie nicht wollen, zu tun, einige makro-Magie, aber ich finde es sauberer ist als die ursprüngliche Lösung.

#include <cstdint>  //for std::uint_fast8_t
#include <array>
#include <string>
#include <iostream>

enum class MyEnum : std::uint_fast8_t {
   AAA,
   BBB,
   CCC,
};

std::ostream& operator<<(std::ostream& str, MyEnum type)
{
    switch(type)
    {
    case MyEnum::AAA: str << "AAA"; break;
    case MyEnum::BBB: str << "BBB"; break;
    case MyEnum::CCC: str << "CCC"; break;
    default: break;
    }
    return str;
}

int main()
{
   std::cout << MyEnum::AAA <<'\n';
}

InformationsquelleAutor der Antwort dau_sama

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Im Gegensatz zu allen anderen ähnlichen Fragen, diese Frage ist über die Verwendung des neuen C++ - Funktionen.

Nach der Lektüre viele Antworten, habe ich noch nicht finden:

Beispiel

Einschränkungen

Schön zu haben

Erklärung

Code

Bearbeiten

Update:

Der Bibliothek (verschmolzen in einer einzigen header-Datei)

Nutzung

Zusammenstellung (kopieren-einfügen-Kopfzeile im main.cpp)

- Ausgang

BEARBEITEN: überprüfen Sie unten für eine neuere version

Enumerator

Nutzung

Einfache Erklärung

Nachteile

Alternative Lösung

Errata

Abhilfe

Nutzung

Real-life-Umsetzung und Verwendung

Kurzanleitung

Code

Erklärung

Vorteile

Disbenefits

Kommentare

Verwendung:

Zusammenstellung (kopieren-einfügen-Kopfzeile im `main.cpp`)