ตรงกันข้ามกับคำถามที่คล้ายกันทั้งหมดคำถามนี้เกี่ยวกับการใช้คุณสมบัติ C ++ ใหม่

• 2008 ค มีวิธีง่าย ๆ ในการแปลง C ++ enum เป็นสายอักขระ?
• 2008 ค วิธีง่ายๆในการใช้ตัวแปรประเภท enum เป็นสตริงใน C?
• 2008 C ++ วิธีการแมป c ++ enums กับสตริงได้อย่างง่ายดาย
• 2008 C ++ ทำบางสิ่งบางอย่างทั้งตัวระบุ C และสตริง?
• 2008 C ++ มีสคริปต์ง่าย ๆ ในการแปลง C ++ enum เป็นสตริงหรือไม่
• 2009 C ++ จะใช้ enums เป็นค่าสถานะใน C ++ ได้อย่างไร
• 2011 C ++ จะแปลงตัวแปรชนิด enum เป็นสตริงได้อย่างไร
• 2011 C ++ Enum เป็น String C ++
• 2011 C ++ จะแปลงตัวแปรชนิด enum เป็นสตริงได้อย่างไร
• 2012 ค วิธีการแปลงชื่อ enum เป็น string ใน c
• 2013 ค Stringing enum ที่คอมไพล์แบบมีเงื่อนไขใน C

หลังจากอ่านคำตอบมากมายฉันยังไม่พบสิ่งใด:

• วิธีที่สง่างามโดยใช้ภาษา C ++ 11 , C ++ 14หรือC ++ 17คุณสมบัติใหม่
• หรือสิ่งที่พร้อมใช้งานในBoost
• มีอะไรที่วางแผนไว้สำหรับC ++ 20

ตัวอย่าง

ตัวอย่างมักจะดีกว่าคำอธิบายที่ยาว
คุณสามารถรวบรวมและเรียกใช้ข้อมูลโค้ดนี้ในColiru
^{( อีกตัวอย่างก่อนหน้านี้ยังมีอยู่)}

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

ข้อ จำกัด

• กรุณาไม่มีการทำซ้ำไร้ค่าของคำตอบอื่น ๆหรือการเชื่อมโยงขั้นพื้นฐาน
• โปรดหลีกเลี่ยงคำตอบจากแมโคร bloat หรือพยายามลด#defineค่าใช้จ่ายให้น้อยที่สุดเท่าที่จะทำได้
• กรุณาไม่มีคู่มือenum-> stringการทำแผนที่

ยินดีที่ได้

• enumค่าสนับสนุนเริ่มต้นจากตัวเลขที่แตกต่างจากศูนย์
• รองรับenumค่าลบ
• สนับสนุนenumค่าที่อยู่อย่างกระจัดกระจาย
• การสนับสนุนclass enum(C ++ 11)
• สนับสนุนการclass enum : <type>มีการอนุญาตใด ๆ<type>(C ++ 11)
• การคอมไพล์เวลา (ไม่ใช่การรันไทม์) การแปลงเป็นสตริง
  หรือการดำเนินการอย่างรวดเร็วในเวลาทำงาน (เช่นstd::mapไม่ใช่ความคิดที่ดี ... )
• constexpr (C ++ 11 จากนั้นผ่อนคลายใน C ++ 14/17/20)
• noexcept (C ++ 11)
• C ++ 17 / C ++ 20ตัวอย่างข้อมูลที่เป็นมิตร

แนวคิดหนึ่งที่เป็นไปได้คือการใช้ความสามารถของคอมไพเลอร์ C ++ เพื่อสร้างโค้ด C ++ ที่เวลารวบรวมโดยใช้เทคนิคการเขียนโปรแกรมเมตาตามvariadic template classและconstexprฟังก์ชั่น ...

ไลบรารีเฉพาะส่วนหัวMagic Enumให้การสะท้อนแบบคงที่สำหรับ enums (ไปยังสตริงจากสตริงการทำซ้ำ) สำหรับ C ++ 17

#include <magic_enum.hpp>

enum Color { RED = 2, BLUE = 4, GREEN = 8 };

Color color = Color::RED;
auto color_name = magic_enum::enum_name(color);
// color_name -> "RED"

std::string color_name{"GREEN"};
auto color = magic_enum::enum_cast<Color>(color_name)
if (color.has_value()) {
  // color.value() -> Color::GREEN
};

สำหรับตัวอย่างเพิ่มเติมบ้านตรวจสอบพื้นที่เก็บข้อมูลhttps://github.com/Neargye/magic_enum

ข้อเสียเปรียบอยู่ที่ไหน

ไลบรารีนี้ใช้แฮ็คเฉพาะคอมไพเลอร์ (อิงจาก__PRETTY_FUNCTION__/ __FUNCSIG__) ซึ่งทำงานกับ Clang> = 5, MSVC> = 15.3 และ GCC> = 9

ค่า Enum [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]ต้องอยู่ในช่วง

• โดยค่าเริ่มต้น,MAGIC_ENUM_RANGE_MIN = -128MAGIC_ENUM_RANGE_MAX = 128

• หากต้องการความหลากหลายสำหรับทุกประเภท enum โดยค่าเริ่มต้นอีก redefine แมโครและMAGIC_ENUM_RANGE_MINMAGIC_ENUM_RANGE_MAX

• MAGIC_ENUM_RANGE_MINจะต้องน้อยกว่าหรือเท่ากับมากกว่าและต้องมากกว่า0INT16_MIN

• MAGIC_ENUM_RANGE_MAXต้องมากกว่าและต้องน้อยกว่า0INT16_MAX

• หากต้องการช่วงอื่นสำหรับประเภท enum เฉพาะให้เพิ่มความเชี่ยวชาญ enum_range สำหรับประเภท enum ที่จำเป็น

  #include <magic_enum.hpp>
  
  enum number { one = 100, two = 200, three = 300 };
  
  namespace magic_enum {
  template <>
    struct enum_range<number> {
      static constexpr int min = 100;
      static constexpr int max = 300;
  };
  }

_{(วิธีการของห้องสมุดbetter_enums )}

มีวิธีที่จะทำให้ Enum เป็นสตริงใน C ++ ปัจจุบันที่มีลักษณะดังนี้:

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

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

การใช้งาน:

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...

constexprการดำเนินงานทั้งหมดสามารถทำ คุณยังสามารถใช้ข้อเสนอการสะท้อน C ++ 17 ที่กล่าวถึงในคำตอบโดย @ecatmur

• มีเพียงแมโครเดียวเท่านั้น ฉันเชื่อว่านี่เป็นค่าต่ำสุดที่เป็นไปได้เนื่องจากการประมวลผลสตริง (preprocessor #) เป็นวิธีเดียวที่จะแปลงโทเค็นเป็นสตริงใน C ++ ปัจจุบัน
• แมโครนั้นไม่สร้างความรำคาญเลยทีเดียว - การประกาศอย่างต่อเนื่องรวมถึงการเริ่มต้นถูกวางลงในการประกาศ enum ในตัว ซึ่งหมายความว่าพวกเขามีไวยากรณ์และความหมายเช่นเดียวกับใน enum ในตัว
• การทำซ้ำถูกกำจัด
• การดำเนินงานที่เป็นธรรมชาติมากที่สุดและมีประโยชน์อย่างน้อย C ++ 11 constexprเนื่องจาก นอกจากนี้ยังสามารถทำให้การทำงานกับ C ++ 98 __VA_ARGS__+ มันเป็น C ++ ที่ทันสมัยอย่างแน่นอน

นิยามของมาโครค่อนข้างเกี่ยวข้องดังนั้นฉันจึงตอบคำถามนี้ได้หลายวิธี

• ส่วนใหญ่ของคำตอบนี้เป็นการใช้งานที่ฉันคิดว่าเหมาะสมสำหรับข้อ จำกัด ด้านพื้นที่ใน StackOverflow
• นอกจากนี้ยังมีบทความ CodeProject ที่อธิบายถึงพื้นฐานของการใช้งานในแบบฝึกหัดแบบยาว [ ฉันควรย้ายที่นี่หรือไม่ ฉันคิดว่ามันมากเกินไปสำหรับคำตอบดังนั้น ]
• มีไลบรารี่เต็มรูปแบบ "Better Enums"ที่ใช้มาโครในไฟล์ส่วนหัวเดียว นอกจากนี้ยังใช้แบบสอบถามคุณสมบัติชนิด N4428การแก้ไขปัจจุบันของข้อเสนอการสะท้อน C ++ 17 N4113 ดังนั้นอย่างน้อยสำหรับ enums ที่ประกาศผ่านแมโครนี้คุณสามารถมีการสะท้อน Enum ของ C ++ 17 ที่เสนอในขณะนี้ใน C ++ 11 / C ++ 14

มันตรงไปตรงมาที่จะขยายคำตอบนี้ให้กับคุณสมบัติของห้องสมุด - ไม่มีสิ่งใด "สำคัญ" ที่เหลืออยู่ที่นี่ อย่างไรก็ตามมันค่อนข้างน่าเบื่อและมีข้อกังวลเรื่องการพกพาคอมไพเลอร์

ข้อจำกัดความรับผิดชอบ : ฉันเป็นผู้เขียนทั้งบทความ CodeProject และห้องสมุด

คุณสามารถลองรหัสในคำตอบนี้ , ห้องสมุดและการดำเนินงานของ N4428ออนไลน์อยู่ใน Wandbox เอกสารประกอบของไลบรารียังมีภาพรวมของวิธีใช้เป็น N4428ซึ่งอธิบายส่วน enums ของข้อเสนอนั้น

คำอธิบาย

รหัสด้านล่างใช้การแปลงระหว่าง enums และสตริง อย่างไรก็ตามมันสามารถขยายออกไปทำสิ่งอื่นได้เช่นกันซ้ำ คำตอบนี้ wraps Enum structที่ใน คุณยังสามารถสร้างลักษณะstructพร้อมกับ enum แทน

กลยุทธ์คือการสร้างสิ่งนี้:

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 */ }
};

ปัญหาคือ:

1. เราจะจบลงด้วยสิ่งที่ชอบ{Red = 1, Green, Blue}เป็น initializer สำหรับอาร์เรย์ค่า นี่ไม่ใช่ C ++ ที่ถูกต้องเนื่องจากRedไม่ใช่นิพจน์ที่กำหนดได้ นี้จะแก้ไขได้โดยการหล่อแต่ละอย่างต่อเนื่องเพื่อประเภทTที่มีผู้ประกอบการที่ได้รับมอบหมาย {(T)Red = 1, (T)Green, (T)Blue}แต่จะลดลงได้รับมอบหมาย:
2. ในทำนองเดียวกันเราจะลงท้ายด้วย{"Red = 1", "Green", "Blue"}initializer สำหรับอาร์เรย์ชื่อ " = 1"เราจะต้องตัดออก ฉันไม่ทราบวิธีที่ดีในการทำเช่นนี้ในเวลารวบรวมดังนั้นเราจะเลื่อนเวลาดำเนินการนี้ไป ดังนั้น_to_stringจะไม่เป็นconstexprแต่_from_stringยังสามารถเป็นได้constexprเพราะเราสามารถรักษาช่องว่างและเครื่องหมายเท่ากับว่าเป็นเทอร์มิเนเตอร์เมื่อเปรียบเทียบกับสตริงที่ไม่ได้รับการดัดแปลง
3. ทั้งความต้องการดังกล่าวข้างต้น "การทำแผนที่" __VA_ARGS__แมโครที่สามารถนำไปใช้แมโครอีกครั้งเพื่อให้แต่ละองค์ประกอบใน นี่เป็นมาตรฐานที่ค่อนข้างดี คำตอบนี้มีเวอร์ชั่นง่าย ๆ ที่สามารถรองรับองค์ประกอบได้มากถึง 8 องค์ประกอบ
4. ถ้าแมโครนั้นมีอยู่ในตัวเองอย่างแท้จริงมันจำเป็นต้องประกาศว่าไม่มีข้อมูลสแตติกที่ต้องใช้คำจำกัดความแยกต่างหาก ในทางปฏิบัติหมายถึงอาร์เรย์จำเป็นต้องได้รับการดูแลเป็นพิเศษ มีสองวิธีที่เป็นไปได้: constexpr(หรือเพียงแค่const) อาร์เรย์ที่ขอบเขตเนมสเปซหรืออาร์เรย์ปกติในconstexprฟังก์ชั่นอินไลน์ไม่คงที่ รหัสในคำตอบนี้สำหรับ C ++ 11 และใช้วิธีการเดิม บทความ CodeProject สำหรับ C ++ 98 และใช้ในภายหลัง

รหัส

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

และ

// 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), "");

โปรแกรมดังกล่าวพิมพ์Redตามที่คุณคาดหวัง มีระดับความปลอดภัยของประเภทเนื่องจากคุณไม่สามารถสร้าง enum โดยไม่ต้องกำหนดค่าเริ่มต้นและการลบหนึ่งในกรณีจากswitchจะส่งผลให้คำเตือนจากคอมไพเลอร์ (ขึ้นอยู่กับคอมไพเลอร์และธงของคุณ) นอกจากนี้โปรดทราบว่า"Red"ถูกแปลงเป็น enum ระหว่างการรวบรวม

สำหรับC ++ 17 C ++ 20 คุณจะสนใจงานของ Reflection Study Group (SG7) มีชุดเอกสารที่ขนานกันครอบคลุมถ้อยคำ ( P0194 ) และเหตุผลการออกแบบและวิวัฒนาการ ( P0385 ) (ลิงก์แก้ไขไปยังกระดาษล่าสุดในแต่ละซีรี่ส์)

ตั้งแต่ P0194r2 (2016-10-15) ไวยากรณ์จะใช้reflexprคำสำคัญที่เสนอ:

meta::get_base_name_v<
  meta::get_element_m<
    meta::get_enumerators_m<reflexpr(MyEnum)>,
    0>
  >

ตัวอย่างเช่น (ดัดแปลงมาจากเสียงสะท้อนจากMatus Choclik's branch ):

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

การสะท้อนคงที่ล้มเหลวในการทำให้เป็น C ++ 17 (แทนที่จะเป็นร่างสุดท้ายที่นำเสนอในการประชุมมาตรฐานเดือนพฤศจิกายน 2559 ที่ Issaquah) แต่มีความมั่นใจว่าจะทำให้เป็น C ++ 20; จากรายงานการเดินทางของ Herb Sutter :

โดยเฉพาะอย่างยิ่ง กลุ่มการศึกษาการสะท้อนทบทวนข้อเสนอการสะท้อนคงที่ที่ผสานล่าสุดและพบว่ามันพร้อมที่จะเข้าสู่กลุ่มวิวัฒนาการหลักในการประชุมครั้งต่อไปของเราเพื่อเริ่มพิจารณาข้อเสนอการสะท้อนคงที่แบบครบวงจรสำหรับ TS หรือมาตรฐานถัดไป

เรื่องนี้คล้ายกับยูริฟินเกลสไตน์; แต่ไม่จำเป็นต้องเพิ่ม ฉันใช้แผนที่เพื่อให้คุณสามารถกำหนดค่าใด ๆ ให้กับ enums, ลำดับใดก็ได้

การประกาศของ enum class เป็น:

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

รหัสต่อไปนี้จะสร้างคลาส enum และโอเวอร์โหลดโดยอัตโนมัติ:

• '+' '+ =' สำหรับ std :: string
• '<<' สำหรับสตรีม
• '~' เพียงแค่แปลงเป็นสตริง (ตัวดำเนินการเอกจะทำ แต่ฉันไม่ชอบมันเพื่อความชัดเจน)
• '*' เพื่อรับจำนวน enums

ไม่จำเป็นต้องเพิ่มฟังก์ชั่นที่จำเป็นทั้งหมดที่มีให้

รหัส:

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

ตัวอย่าง:

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

You can run the code here

ย้อนกลับไปในปี 2554 ฉันใช้เวลาช่วงสุดสัปดาห์ปรับจูนโซลูชั่นแบบมาโครและลงเอยด้วยการไม่เคยใช้เลย

ขั้นตอนปัจจุบันของฉันคือการเริ่ม Vim คัดลอกตัวแจงนับในตัวสวิตช์ว่างเริ่มแมโครใหม่แปลงตัวแจงนับตัวแรกเป็นคำสั่ง case ย้ายเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดถัดไปหยุดแมโครและสร้างกรณีที่เหลือ คำสั่งโดยการเรียกใช้แมโครบนตัวแจงนับอื่น ๆ

Vim macros สนุกกว่ามาโคร C ++

ตัวอย่างชีวิตจริง:

enum class EtherType : uint16_t
{
    ARP   = 0x0806,
    IPv4  = 0x0800,
    VLAN  = 0x8100,
    IPv6  = 0x86DD
};

ฉันจะสร้างสิ่งนี้:

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

และนั่นคือวิธีที่ฉันได้รับโดย

การสนับสนุนดั้งเดิมสำหรับ enum stringification จะดีกว่ามาก ฉันสนใจมากที่จะเห็นผลลัพธ์ของกลุ่มงานไตร่ตรองใน C ++ 17

ทางเลือกที่จะทำมันถูกโพสต์โดย @sehe ในการแสดงความคิดเห็น

ฉันไม่รู้ว่าคุณจะชอบสิ่งนี้หรือไม่ฉันไม่ค่อยพอใจกับโซลูชันนี้ แต่เป็นวิธีที่เป็นมิตรกับ C ++ 14 เพราะใช้ตัวแปรเท็มเพลตและการใช้เทมเพลตที่ไม่เหมาะสม:

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

สิ่งที่แย่ที่สุดเกี่ยวกับวิธีการนี้คือความเจ็บปวดในการรักษา แต่มันก็เป็นความเจ็บปวดในการรักษาปัญหาที่คล้ายกันอื่น ๆ ใช่ไหม?

ข้อดีของโปรแกรมนี้:

• การใช้ตัวแปรชั่วคราว (คุณสมบัติ C ++ 14)
• ด้วยความเชี่ยวชาญด้านเทมเพลตเราสามารถ "ตรวจจับ" เมื่อมีการใช้ค่าที่ไม่ถูกต้อง (แต่ฉันไม่แน่ใจว่าสิ่งนี้จะมีประโยชน์หรือไม่)
• มันดูเรียบร้อย
• การค้นหาชื่อเสร็จสิ้นในเวลารวบรวม

Live example

แก้ไข

Misterious user673679คุณพูดถูก วิธีเทมเพลตตัวแปร C ++ 14 นั้นไม่ได้จัดการกับกรณีรันไทม์มันเป็นความผิดของฉันที่จะลืมมัน :(

แต่เรายังคงสามารถใช้คุณสมบัติ C ++ ที่ทันสมัยและเทมเพลตตัวแปรพร้อมกลอุบายเทมเพลต Variadic เพื่อให้ได้การแปลแบบรันไทม์จากค่า enum เป็น string ... มันน่ารำคาญเหมือนอย่างอื่น แต่ยังคุ้มที่จะกล่าวถึง

มาเริ่มใช้ชื่อแทนแม่แบบเพื่อย่อการเข้าถึงแผนที่ enum-to-string

// 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{};

จากนั้นแม่แบบ Variadic ที่ใช้เล่ห์เหลี่ยม:

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

" เคล็ดลับที่ดีที่สุด " ที่นี่คือการใช้แม่แบบตัวแปรสำหรับแผนที่ซึ่งมีค่าและชื่อของแต่ละรายการ enum; แผนที่นี้จะเหมือนกันในแต่ละหน่วยการแปลและมีชื่อเหมือนกันทุกที่ดังนั้นค่อนข้างตรงไปตรงมาและเรียบร้อยถ้าเราเรียกinitializeฟังก์ชั่นเช่นนี้:

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

เรากำลังกำหนดชื่อให้แต่ละMyEnumรายการและสามารถใช้ในรันไทม์:

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

แต่สามารถปรับปรุงได้ด้วย SFINAE และ<<ตัวดำเนินการโอเวอร์โหลด:

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

ด้วยความถูกต้องoperator <<ตอนนี้เราสามารถใช้ Enum ด้วยวิธีนี้:

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

นี่เป็นเรื่องที่น่ารำคาญในการรักษาและปรับปรุงให้ดีขึ้น แต่หวังว่าคุณจะเข้าใจ

Live example

หากคุณenumดูเหมือน

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

คุณสามารถย้ายเนื้อหาของenumไปยังไฟล์ใหม่:

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

จากนั้นค่าสามารถถูกล้อมรอบด้วยมาโคร:

// 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

ขั้นตอนถัดไปอาจรวมถึงรายการในenumอีกครั้ง:

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

และในที่สุดคุณสามารถสร้างฟังก์ชั่นยูทิลิตี้เกี่ยวกับเรื่องนี้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");
}

โซลูชันสามารถใช้กับมาตรฐาน C ++ ที่เก่ากว่าและไม่ใช้องค์ประกอบ C ++ ที่ทันสมัย ​​แต่สามารถใช้เพื่อสร้างรหัสจำนวนมากโดยไม่ต้องใช้ความพยายามและการบำรุงรักษามากเกินไป

ฉันมีปัญหาเดียวกันสองสามวันที่ผ่านมา ฉันไม่สามารถหาวิธีแก้ปัญหา C ++ ได้หากไม่มีแมโคเวทแปลก ๆ ดังนั้นฉันจึงตัดสินใจเขียนตัวสร้างโค้ด CMakeเพื่อสร้างคำสั่งตัวพิมพ์กรณีที่เรียบง่าย

การใช้งาน:

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

ฟังก์ชั่นการค้นหาไฟล์รวมในระบบไฟล์ (ใช้ไดเรกทอรีรวมให้มาพร้อมกับคำสั่ง include_directories) อ่านพวกเขาและจะ regex บางส่วนเพื่อสร้างชั้นเรียนและฟังก์ชั่น

หมายเหตุ: constexpr หมายถึงแบบอินไลน์ใน C ++ ดังนั้นการใช้ตัวเลือก USE_CONSTEXPR จะสร้างคลาสส่วนหัวเท่านั้น!

ตัวอย่าง:

./includes/ah:

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")

สร้าง:

./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>";
   }
}
}

ปรับปรุง:

ตอนนี้สคริปต์ยังรองรับการระบุขอบเขต (enum class | struct) และฉันย้ายมันไปที่ repo ที่แยกจากกันด้วยสคริปต์อื่น ๆ ที่ฉันมักใช้: https://github.com/mensinda/cmakeBuildTools

เพียงแค่สร้าง enums ของคุณ การเขียนตัวสร้างเพื่อจุดประสงค์นั้นใช้เวลาประมาณห้านาที

รหัสเครื่องกำเนิดไฟฟ้าใน java และ python ง่ายต่อการย้ายไปยังภาษาใด ๆ ที่คุณต้องการรวมถึง C ++

นอกจากนี้ยังง่ายต่อการขยายด้วยฟังก์ชั่นที่คุณต้องการ

อินพุตตัวอย่าง:

First = 5
Second
Third = 7
Fourth
Fifth=11

ส่วนหัวที่สร้าง:

#include <iosfwd>

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

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

สร้างไฟล์ cpp

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

และเครื่องกำเนิดไฟฟ้าในรูปแบบสั้นมากเป็นแม่แบบสำหรับการย้ายและการขยาย โค้ดตัวอย่างนี้พยายามหลีกเลี่ยงการเขียนทับไฟล์ใด ๆ แต่ยังคงใช้งานโดยยอมรับความเสี่ยงเอง

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

และพอร์ตไปยัง Python 3.5 เพราะแตกต่างกันมากพอที่จะเป็นประโยชน์

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()

ตามคำขอจาก OP ต่อไปนี้เป็นวิธีแก้ปัญหามาโครที่น่าเกลียดในเวอร์ชั่นนี้โดยใช้Boost Preprosessorและมาโคร Variadicแมโคร

จะช่วยให้รายการง่าย ๆ เช่นไวยากรณ์ขององค์ประกอบ enumerator พร้อมกับการตั้งค่าสำหรับองค์ประกอบเฉพาะเพื่อให้

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

ขยายเป็น

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

ควบคู่ไปกับฟังก์ชั่นที่จำเป็นในการส่งออกและทำการแปลงกลับบางส่วน มาโครนี้อยู่ที่นี่มานานแล้วและฉันก็ไม่แน่ใจว่ามันเป็นวิธีที่มีประสิทธิภาพมากที่สุดหรือเป็นวิธีที่สอดคล้องกัน

รหัสที่สมบูรณ์สามารถมองเห็นได้ในการกระทำที่ทั้งIdeoneและColiru

ความอัปลักษณ์ที่ยิ่งใหญ่ของมันนั้นเหนือกว่า ฉันจะวางไว้ด้านหลังสปอยเลอร์เพื่อปกป้องดวงตาของคุณถ้าฉันรู้ว่า แต่มาร์คไม่ชอบฉัน

ไลบรารี (ผสานภายในไฟล์ส่วนหัวเดียว)

#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)