นี่คือสิ่งที่ฉันพยายามทำ:

typedef enum { ONE, TWO, THREE } Numbers;

ฉันกำลังพยายามเขียนฟังก์ชันที่จะทำกรณีสวิตช์คล้ายกับต่อไปนี้:

char num_str[10];
int process_numbers_str(Numbers num) {
  switch(num) {
    case ONE:
    case TWO:
    case THREE:
    {
      strcpy(num_str, num); //some way to get the symbolic constant name in here?
    } break;
    default:
      return 0; //no match
  return 1;
}

แทนที่จะกำหนดทุกกรณีมีวิธีตั้งค่าโดยใช้ตัวแปร enum เหมือนที่ฉันพยายามทำข้างต้นหรือไม่?

ไม่มีโซลูชันในตัว วิธีที่ง่ายที่สุดคือการใช้อาร์เรย์char*ที่ค่า int ของ enum ทำดัชนีเป็นสตริงที่มีชื่อสื่อความหมายของ enum นั้น หากคุณมีค่าเบาบางenum(รายการที่ไม่ได้เริ่มต้นที่ 0 หรือมีช่องว่างในการกำหนดหมายเลข) โดยที่การintแมปบางส่วนนั้นสูงพอที่จะทำให้การแมปแบบอาร์เรย์ไม่สามารถทำได้คุณสามารถใช้ตารางแฮชแทนได้

เทคนิคจากการสร้างบางสิ่งบางอย่างทั้งตัวระบุ C และสตริง? สามารถใช้ได้ที่นี่

ตามปกติสำหรับสิ่งก่อนโปรเซสเซอร์เช่นนี้การเขียนและทำความเข้าใจส่วนของตัวประมวลผลล่วงหน้าอาจเป็นเรื่องยากและรวมถึงการส่งผ่านมาโครไปยังมาโครอื่น ๆ และเกี่ยวข้องกับการใช้ตัวดำเนินการ # และ ## แต่การใช้งานนั้นง่ายมาก ฉันพบว่าสไตล์นี้มีประโยชน์มากสำหรับ enums ที่ยาวนานซึ่งการรักษารายการเดิมสองครั้งอาจเป็นปัญหา

รหัสโรงงาน - พิมพ์เพียงครั้งเดียวโดยปกติจะซ่อนอยู่ในส่วนหัว:

enumFactory.h:

// expansion macro for enum value definition
#define ENUM_VALUE(name,assign) name assign,

// expansion macro for enum to string conversion
#define ENUM_CASE(name,assign) case name: return #name;

// expansion macro for string to enum conversion
#define ENUM_STRCMP(name,assign) if (!strcmp(str,#name)) return name;

/// declare the access function and define enum values
#define DECLARE_ENUM(EnumType,ENUM_DEF) \
  enum EnumType { \
    ENUM_DEF(ENUM_VALUE) \
  }; \
  const char *GetString(EnumType dummy); \
  EnumType Get##EnumType##Value(const char *string); \

/// define the access function names
#define DEFINE_ENUM(EnumType,ENUM_DEF) \
  const char *GetString(EnumType value) \
  { \
    switch(value) \
    { \
      ENUM_DEF(ENUM_CASE) \
      default: return ""; /* handle input error */ \
    } \
  } \
  EnumType Get##EnumType##Value(const char *str) \
  { \
    ENUM_DEF(ENUM_STRCMP) \
    return (EnumType)0; /* handle input error */ \
  } \

โรงงานที่ใช้

someEnum.h:

#include "enumFactory.h"
#define SOME_ENUM(XX) \
    XX(FirstValue,) \
    XX(SecondValue,) \
    XX(SomeOtherValue,=50) \
    XX(OneMoreValue,=100) \

DECLARE_ENUM(SomeEnum,SOME_ENUM)

someEnum.cpp:

#include "someEnum.h"
DEFINE_ENUM(SomeEnum,SOME_ENUM)

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

เปรียบเทียบกับ X-Macros โดยใช้ #include / #define / #undef

แม้ว่าสิ่งนี้จะคล้ายกับ X-Macros อื่น ๆ ที่กล่าวถึง แต่ฉันคิดว่าโซลูชันนี้มีความสง่างามกว่าที่ไม่ต้องการ #undefing อะไรเลยซึ่งช่วยให้คุณซ่อนสิ่งที่ซับซ้อนได้มากขึ้นในไฟล์ส่วนหัว - ไฟล์ส่วนหัว เป็นสิ่งที่คุณไม่ได้สัมผัสเลยเมื่อคุณต้องการกำหนด enum ใหม่ดังนั้นนิยาม enum ใหม่จึงสั้นและสะอาดกว่ามาก

// Define your enumeration like this (in say numbers.h);
ENUM_BEGIN( Numbers )
    ENUM(ONE),
    ENUM(TWO),
    ENUM(FOUR)
ENUM_END( Numbers )

// The macros are defined in a more fundamental .h file (say defs.h);
#define ENUM_BEGIN(typ) enum typ {
#define ENUM(nam) nam
#define ENUM_END(typ) };

// Now in one and only one .c file, redefine the ENUM macros and reinclude
//  the numbers.h file to build a string table
#undef ENUM_BEGIN
#undef ENUM
#undef ENUM_END
#define ENUM_BEGIN(typ) const char * typ ## _name_table [] = {
#define ENUM(nam) #nam
#define ENUM_END(typ) };
#undef NUMBERS_H_INCLUDED   // whatever you need to do to enable reinclusion
#include "numbers.h"

// Now you can do exactly what you want to do, with no retyping, and for any
//  number of enumerated types defined with the ENUM macro family
//  Your code follows;
char num_str[10];
int process_numbers_str(Numbers num) {
  switch(num) {
    case ONE:
    case TWO:
    case THREE:
    {
      strcpy(num_str, Numbers_name_table[num]); // eg TWO -> "TWO"
    } break;
    default:
      return 0; //no match
  return 1;
}

// Sweet no ? After being frustrated by this for years, I finally came up
//  with this solution for my most recent project and plan to reuse the idea
//  forever

มีแน่นอนวิธีที่จะทำเช่นนี้ - การใช้งานX () แมโคร มาโครเหล่านี้ใช้ตัวประมวลผลก่อน C เพื่อสร้าง enums อาร์เรย์และบล็อกโค้ดจากรายการแหล่งข้อมูล คุณจะต้องเพิ่มรายการใหม่ใน #define ที่มีมาโคร X () เท่านั้น คำสั่งสวิตช์จะขยายโดยอัตโนมัติ

ตัวอย่างของคุณสามารถเขียนได้ดังนี้:

 // Source data -- Enum, String
 #define X_NUMBERS \
    X(ONE,   "one") \
    X(TWO,   "two") \
    X(THREE, "three")

 ...

 // Use preprocessor to create the Enum
 typedef enum {
  #define X(Enum, String)       Enum,
   X_NUMBERS
  #undef X
 } Numbers;

 ...

 // Use Preprocessor to expand data into switch statement cases
 switch(num)
 {
 #define X(Enum, String) \
     case Enum:  strcpy(num_str, String); break;
 X_NUMBERS
 #undef X

     default: return 0; break;
 }
 return 1;

มีวิธีที่มีประสิทธิภาพมากขึ้น (เช่นการใช้ X Macros เพื่อสร้างสตริงอาร์เรย์และดัชนี enum) แต่นี่เป็นการสาธิตที่ง่ายที่สุด

ฉันรู้ว่าคุณมีคำตอบที่ดีสองสามข้อ แต่คุณรู้เกี่ยวกับตัวดำเนินการ # ในตัวประมวลผลก่อนหน้าหรือไม่

ช่วยให้คุณทำสิ่งนี้:

#define MACROSTR(k) #k

typedef enum {
    kZero,
    kOne,
    kTwo,
    kThree
} kConst;

static char *kConstStr[] = {
    MACROSTR(kZero),
    MACROSTR(kOne),
    MACROSTR(kTwo),
    MACROSTR(kThree)
};

static void kConstPrinter(kConst k)
{
    printf("%s", kConstStr[k]);
}

C หรือ C ++ ไม่มีฟังก์ชันนี้แม้ว่าฉันจะต้องการบ่อยครั้งก็ตาม

รหัสต่อไปนี้ใช้งานได้แม้ว่าจะเหมาะที่สุดสำหรับ enums ที่ไม่กระจัดกระจาย

typedef enum { ONE, TWO, THREE } Numbers;
char *strNumbers[] = {"one","two","three"};
printf ("Value for TWO is %s\n",strNumbers[TWO]);

โดยไม่กระจัดกระจายฉันไม่ได้หมายถึงรูปแบบ

typedef enum { ONE, FOUR_THOUSAND = 4000 } Numbers;

เนื่องจากมีช่องว่างมาก

ข้อดีของวิธีนี้คือทำให้คำจำกัดความของ enums และสตริงอยู่ใกล้กัน การมีคำสั่งสวิตช์ในฟังก์ชันจะทำให้พวกเขาพูดถึง ซึ่งหมายความว่าคุณมีโอกาสน้อยที่จะเปลี่ยนแปลงโดยไม่มีอีกฝ่าย

จูบ. คุณจะทำสวิตช์ / เคสอื่น ๆ ทุกประเภทด้วย enums ของคุณดังนั้นทำไมการพิมพ์จึงแตกต่างกัน? การลืมเคสในกิจวัตรการพิมพ์ของคุณไม่ใช่เรื่องใหญ่เมื่อคุณคิดว่ามีสถานที่อื่น ๆ อีกประมาณ 100 แห่งที่คุณสามารถลืมเคสได้ เพียงคอมไพล์ -Wall ซึ่งจะเตือนถึงกรณีที่ไม่ตรงกันทั้งหมด อย่าใช้ "ค่าเริ่มต้น" เพราะจะทำให้สวิตช์หมดจดและคุณจะไม่ได้รับคำเตือน แทนที่จะปล่อยให้สวิตช์ออกและจัดการกับกรณีเริ่มต้นเช่นนั้น ...

const char *myenum_str(myenum e)
{
    switch(e) {
    case ONE: return "one";
    case TWO: return "two";
    }
    return "invalid";
}

ลองแปลง c ++ enums สตริง ความเห็นมีการปรับปรุงที่แก้ปัญหาที่เกิดขึ้นเมื่อรายการ enum มีค่าโดยพลการ

การใช้boost :: preprocessorทำให้เป็นไปได้ที่จะแก้ปัญหาที่สวยงามดังต่อไปนี้:

ขั้นตอนที่ 1: รวมไฟล์ส่วนหัว:

#include "EnumUtilities.h"

ขั้นตอนที่ 2: ประกาศอ็อบเจ็กต์การแจงนับด้วยไวยากรณ์ต่อไปนี้:

MakeEnum( TestData,
         (x)
         (y)
         (z)
         );

ขั้นตอนที่ 3: ใช้ข้อมูลของคุณ:

รับจำนวนองค์ประกอบ:

td::cout << "Number of Elements: " << TestDataCount << std::endl;

รับสตริงที่เกี่ยวข้อง:

std::cout << "Value of " << TestData2String(x) << " is " << x << std::endl;
std::cout << "Value of " << TestData2String(y) << " is " << y << std::endl;
std::cout << "Value of " << TestData2String(z) << " is " << z << std::endl;

การรับค่า enum จากสตริงที่เกี่ยวข้อง:

std::cout << "Value of x is " << TestData2Enum("x") << std::endl;
std::cout << "Value of y is " << TestData2Enum("y") << std::endl;
std::cout << "Value of z is " << TestData2Enum("z") << std::endl;

มันดูสะอาดและกะทัดรัดโดยไม่มีไฟล์เพิ่มเติมให้รวม รหัสที่ฉันเขียนภายใน EnumUtilities.h มีดังต่อไปนี้:

#include <boost/preprocessor/seq/for_each.hpp>
#include <string>

#define REALLY_MAKE_STRING(x) #x
#define MAKE_STRING(x) REALLY_MAKE_STRING(x)
#define MACRO1(r, data, elem) elem,
#define MACRO1_STRING(r, data, elem)    case elem: return REALLY_MAKE_STRING(elem);
#define MACRO1_ENUM(r, data, elem)      if (REALLY_MAKE_STRING(elem) == eStrEl) return elem;


#define MakeEnum(eName, SEQ) \
    enum eName { BOOST_PP_SEQ_FOR_EACH(MACRO1, , SEQ) \
    last_##eName##_enum}; \
    const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
    static std::string eName##2String(const enum eName eel) \
    { \
        switch (eel) \
        { \
        BOOST_PP_SEQ_FOR_EACH(MACRO1_STRING, , SEQ) \
        default: return "Unknown enumerator value."; \
        }; \
    }; \
    static enum eName eName##2Enum(const std::string eStrEl) \
    { \
        BOOST_PP_SEQ_FOR_EACH(MACRO1_ENUM, , SEQ) \
        return (enum eName)0; \
    };

มีข้อ จำกัด บางประการ ได้แก่ ตัวประมวลผล boost :: preprocessor ในกรณีนี้รายการค่าคงที่ต้องมีขนาดไม่เกิน 64 องค์ประกอบ

ตามตรรกะเดียวกันคุณสามารถคิดที่จะสร้าง enum กระจัดกระจาย:

#define EnumName(Tuple)                 BOOST_PP_TUPLE_ELEM(2, 0, Tuple)
#define EnumValue(Tuple)                BOOST_PP_TUPLE_ELEM(2, 1, Tuple)
#define MACRO2(r, data, elem)           EnumName(elem) EnumValue(elem),
#define MACRO2_STRING(r, data, elem)    case EnumName(elem): return BOOST_PP_STRINGIZE(EnumName(elem));

#define MakeEnumEx(eName, SEQ) \
    enum eName { \
    BOOST_PP_SEQ_FOR_EACH(MACRO2, _, SEQ) \
    last_##eName##_enum }; \
    const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
    static std::string eName##2String(const enum eName eel) \
    { \
        switch (eel) \
        { \
        BOOST_PP_SEQ_FOR_EACH(MACRO2_STRING, _, SEQ) \
        default: return "Unknown enumerator value."; \
        }; \
    };  

ในกรณีนี้ไวยากรณ์คือ:

MakeEnumEx(TestEnum,
           ((x,))
           ((y,=1000))
           ((z,))
           );

การใช้งานจะคล้ายกับด้านบน (ลบฟังก์ชัน eName ## 2Enum ซึ่งคุณสามารถลองอนุมานจากไวยากรณ์ก่อนหน้านี้ได้)

ฉันทดสอบบน mac และ linux แต่โปรดทราบว่า boost :: preprocessor อาจไม่สามารถพกพาได้อย่างสมบูรณ์

ด้วยการรวมเทคนิคบางอย่างเข้าด้วยกันฉันได้รูปแบบที่ง่ายที่สุด:

#define MACROSTR(k) #k

#define X_NUMBERS \
       X(kZero  ) \
       X(kOne   ) \
       X(kTwo   ) \
       X(kThree ) \
       X(kFour  ) \
       X(kMax   )

enum {
#define X(Enum)       Enum,
    X_NUMBERS
#undef X
} kConst;

static char *kConstStr[] = {
#define X(String) MACROSTR(String),
    X_NUMBERS
#undef X
};

int main(void)
{
    int k;
    printf("Hello World!\n\n");

    for (k = 0; k < kMax; k++)
    {
        printf("%s\n", kConstStr[k]);
    }

    return 0;
}

หากคุณใช้ gcc สามารถใช้:

const char * enum_to_string_map[]={ [enum1]='string1', [enum2]='string2'};

จากนั้นก็โทรหาเช่น

enum_to_string_map[enum1]

ตรวจสอบความคิดที่หมู่ Dynamics ห้องปฏิบัติการวิจัย - คลังบทความของบล็อก ฉันพบสิ่งนี้เมื่อต้นปีนี้ - ฉันลืมบริบทที่แน่นอนที่ฉันเจอ - และได้ดัดแปลงเป็นรหัสนี้ เราสามารถอภิปรายข้อดีของการเพิ่ม E ที่ด้านหน้า ใช้ได้กับปัญหาเฉพาะที่ได้รับการแก้ไข แต่ไม่ใช่ส่วนหนึ่งของวิธีแก้ปัญหาทั่วไป ฉันเก็บสิ่งนี้ไว้ในโฟลเดอร์ 'สะเปะสะปะ' - ซึ่งฉันเก็บเรื่องที่น่าสนใจของโค้ดไว้เผื่อว่าฉันต้องการมันในภายหลัง ฉันอายที่จะบอกว่าฉันไม่ได้จดบันทึกว่าความคิดนี้มาจากไหนในเวลานั้น

ส่วนหัว: paste1.h

/*
@(#)File:           $RCSfile: paste1.h,v $
@(#)Version:        $Revision: 1.1 $
@(#)Last changed:   $Date: 2008/05/17 21:38:05 $
@(#)Purpose:        Automated Token Pasting
*/

#ifndef JLSS_ID_PASTE_H
#define JLSS_ID_PASTE_H

/*
 * Common case when someone just includes this file.  In this case,
 * they just get the various E* tokens as good old enums.
 */
#if !defined(ETYPE)
#define ETYPE(val, desc) E##val,
#define ETYPE_ENUM
enum {
#endif /* ETYPE */

   ETYPE(PERM,  "Operation not permitted")
   ETYPE(NOENT, "No such file or directory")
   ETYPE(SRCH,  "No such process")
   ETYPE(INTR,  "Interrupted system call")
   ETYPE(IO,    "I/O error")
   ETYPE(NXIO,  "No such device or address")
   ETYPE(2BIG,  "Arg list too long")

/*
 * Close up the enum block in the common case of someone including
 * this file.
 */
#if defined(ETYPE_ENUM)
#undef ETYPE_ENUM
#undef ETYPE
ETYPE_MAX
};
#endif /* ETYPE_ENUM */

#endif /* JLSS_ID_PASTE_H */

แหล่งที่มาตัวอย่าง:

/*
@(#)File:           $RCSfile: paste1.c,v $
@(#)Version:        $Revision: 1.2 $
@(#)Last changed:   $Date: 2008/06/24 01:03:38 $
@(#)Purpose:        Automated Token Pasting
*/

#include "paste1.h"

static const char *sys_errlist_internal[] = {
#undef JLSS_ID_PASTE_H
#define ETYPE(val, desc) desc,
#include "paste1.h"
    0
#undef ETYPE
};

static const char *xerror(int err)
{
    if (err >= ETYPE_MAX || err <= 0)
        return "Unknown error";
    return sys_errlist_internal[err];
}

static const char*errlist_mnemonics[] = {
#undef JLSS_ID_PASTE_H
#define ETYPE(val, desc) [E ## val] = "E" #val,
#include "paste1.h"
#undef ETYPE
};

#include <stdio.h>

int main(void)
{
    int i;

    for (i = 0; i < ETYPE_MAX; i++)
    {
        printf("%d: %-6s: %s\n", i, errlist_mnemonics[i], xerror(i));
    }
    return(0);
}

ไม่จำเป็นต้องใช้ก่อนโปรเซสเซอร์ C ที่สะอาดที่สุดในโลก - แต่จะป้องกันการเขียนเนื้อหาหลายครั้ง

สร้างสิ่งที่เป็นทั้งตัวระบุ C และสตริง

หากดัชนี enum เป็น 0 คุณสามารถใส่ชื่อในอาร์เรย์ของถ่าน * และจัดทำดัชนีด้วยค่า enum

#define stringify( name ) # name

enum MyEnum {
    ENUMVAL1
};
...stuff...

stringify(EnumName::ENUMVAL1);  // Returns MyEnum::ENUMVAL1

การอภิปรายเพิ่มเติมเกี่ยวกับวิธีนี้

เคล็ดลับคำสั่ง Preprocessor สำหรับผู้มาใหม่

ฉันได้สร้างง่ายๆเทมเพลตระดับstreamable_enumที่ใช้สตรีมผู้ประกอบการ<<และ>>และขึ้นอยู่กับstd::map<Enum, std::string>:

#ifndef STREAMABLE_ENUM_HPP
#define STREAMABLE_ENUM_HPP

#include <iostream>
#include <string>
#include <map>

template <typename E>
class streamable_enum
{
public:
    typedef typename std::map<E, std::string> tostr_map_t;
    typedef typename std::map<std::string, E> fromstr_map_t;

    streamable_enum()
    {}

    streamable_enum(E val) :
        Val_(val)
    {}

    operator E() {
        return Val_;
    }

    bool operator==(const streamable_enum<E>& e) {
        return this->Val_ == e.Val_;
    }

    bool operator==(const E& e) {
        return this->Val_ == e;
    }

    static const tostr_map_t& to_string_map() {
        static tostr_map_t to_str_(get_enum_strings<E>());
        return to_str_;
    }

    static const fromstr_map_t& from_string_map() {
        static fromstr_map_t from_str_(reverse_map(to_string_map()));
        return from_str_;
    }
private:
    E Val_;

    static fromstr_map_t reverse_map(const tostr_map_t& eToS) {
        fromstr_map_t sToE;
        for (auto pr : eToS) {
            sToE.emplace(pr.second, pr.first);
        }
        return sToE;
    }
};

template <typename E>
streamable_enum<E> stream_enum(E e) {
    return streamable_enum<E>(e);
}

template <typename E>
typename streamable_enum<E>::tostr_map_t get_enum_strings() {
    // \todo throw an appropriate exception or display compile error/warning
    return {};
}

template <typename E>
std::ostream& operator<<(std::ostream& os, streamable_enum<E> e) {
    auto& mp = streamable_enum<E>::to_string_map();
    auto res = mp.find(e);
    if (res != mp.end()) {
        os << res->second;
    } else {
        os.setstate(std::ios_base::failbit);
    }
    return os;
}

template <typename E>
std::istream& operator>>(std::istream& is, streamable_enum<E>& e) {
    std::string str;
    is >> str;
    if (str.empty()) {
        is.setstate(std::ios_base::failbit);
    }
    auto& mp = streamable_enum<E>::from_string_map();
    auto res = mp.find(str);
    if (res != mp.end()) {
        e = res->second;
    } else {
        is.setstate(std::ios_base::failbit);
    }
    return is;
}

#endif

การใช้งาน:

#include "streamable_enum.hpp"

using std::cout;
using std::cin;
using std::endl;

enum Animal {
    CAT,
    DOG,
    TIGER,
    RABBIT
};

template <>
streamable_enum<Animal>::tostr_map_t get_enum_strings<Animal>() {
    return {
        { CAT, "Cat"},
        { DOG, "Dog" },
        { TIGER, "Tiger" },
        { RABBIT, "Rabbit" }
    };
}

int main(int argc, char* argv []) {
    cout << "What animal do you want to buy? Our offering:" << endl;
    for (auto pr : streamable_enum<Animal>::to_string_map()) {          // Use from_string_map() and pr.first instead
        cout << " " << pr.second << endl;                               // to have them sorted in alphabetical order
    }
    streamable_enum<Animal> anim;
    cin >> anim;
    if (!cin) {
        cout << "We don't have such animal here." << endl;
    } else if (anim == Animal::TIGER) {
        cout << stream_enum(Animal::TIGER) << " was a joke..." << endl;
    } else {
        cout << "Here you are!" << endl;
    }

    return 0;
}

นี่คือวิธีแก้ปัญหาโดยใช้มาโครที่มีคุณสมบัติดังต่อไปนี้:

1. เขียนแต่ละค่าของ enum เพียงครั้งเดียวดังนั้นจึงไม่มีรายการคู่ที่ต้องรักษา

2. อย่าเก็บค่า enum ไว้ในไฟล์แยกต่างหากซึ่งเป็น #included ในภายหลังดังนั้นฉันจึงสามารถเขียนได้ทุกที่ที่ต้องการ

3. อย่าแทนที่ enum เองฉันยังคงต้องการกำหนดประเภท enum แต่นอกจากนี้ฉันต้องการที่จะสามารถแมปชื่อ enum ทุกตัวกับสตริงที่เกี่ยวข้อง (เพื่อไม่ให้มีผลกับรหัสเดิม)

4. การค้นหาควรเป็นไปอย่างรวดเร็วดังนั้นจึงไม่ควรเปลี่ยนเคสสำหรับ enums ขนาดใหญ่เหล่านั้น

https://stackoverflow.com/a/20134475/1812866

ฉันคิดว่าวิธีแก้ปัญหาเช่น Boost Fusion one สำหรับการปรับโครงสร้างและคลาสน่าจะดีพวกเขายังมีอยู่ในบางจุดเพื่อใช้ enums เป็นลำดับฟิวชั่น

ฉันจึงสร้างมาโครเล็ก ๆ ขึ้นมาเพื่อสร้างโค้ดเพื่อพิมพ์ enums สิ่งนี้ไม่สมบูรณ์แบบและไม่มีอะไรให้เห็นด้วย Boost รหัสสำเร็จรูปสร้างฟิวชั่น แต่สามารถใช้งานได้เหมือนมาโคร Boost Fusion ฉันต้องการสร้างประเภทที่ Boost ต้องการจริงๆ Fusion เพื่อรวมเข้ากับโครงสร้างพื้นฐานนี้ซึ่งอนุญาตให้พิมพ์ชื่อของสมาชิกโครงสร้าง แต่สิ่งนี้จะเกิดขึ้นในภายหลังตอนนี้เป็นเพียงมาโคร:

#ifndef SWISSARMYKNIFE_ENUMS_ADAPT_ENUM_HPP
#define SWISSARMYKNIFE_ENUMS_ADAPT_ENUM_HPP

#include <swissarmyknife/detail/config.hpp>

#include <string>
#include <ostream>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/seq/for_each.hpp>


#define SWISSARMYKNIFE_ADAPT_ENUM_EACH_ENUMERATION_ENTRY_C(                     \
    R, unused, ENUMERATION_ENTRY)                                               \
    case ENUMERATION_ENTRY:                                                     \
      return BOOST_PP_STRINGIZE(ENUMERATION_ENTRY);                             \
    break;                                                                      

/**
 * \brief Adapts ENUM to reflectable types.
 *
 * \param ENUM_TYPE To be adapted
 * \param ENUMERATION_SEQ Sequence of enum states
 */
#define SWISSARMYKNIFE_ADAPT_ENUM(ENUM_TYPE, ENUMERATION_SEQ)                   \
    inline std::string to_string(const ENUM_TYPE& enum_value) {                 \
      switch (enum_value) {                                                     \
      BOOST_PP_SEQ_FOR_EACH(                                                    \
          SWISSARMYKNIFE_ADAPT_ENUM_EACH_ENUMERATION_ENTRY_C,                   \
          unused, ENUMERATION_SEQ)                                              \
        default:                                                                \
          return BOOST_PP_STRINGIZE(ENUM_TYPE);                                 \
      }                                                                         \
    }                                                                           \
                                                                                \
    inline std::ostream& operator<<(std::ostream& os, const ENUM_TYPE& value) { \
      os << to_string(value);                                                   \
      return os;                                                                \
    }

#endif

คำตอบเก่า ๆ ด้านล่างค่อนข้างแย่โปรดอย่าใช้คำตอบนั้น :)

คำตอบเก่า:

ฉันได้ค้นหาวิธีที่สามารถแก้ปัญหานี้ได้โดยไม่ต้องเปลี่ยนไวยากรณ์การประกาศ enums มากเกินไป ฉันมาถึงโซลูชันที่ใช้ตัวประมวลผลล่วงหน้าเพื่อดึงสตริงจากการประกาศ enum แบบสตริง

ฉันสามารถกำหนด enums ที่ไม่กระจัดกระจายเช่นนี้:

SMART_ENUM(State, 
    enum State {
        RUNNING,
        SLEEPING, 
        FAULT, 
        UNKNOWN
    })

และฉันสามารถโต้ตอบกับพวกเขาได้หลายวิธี:

// With a stringstream
std::stringstream ss;
ss << State::FAULT;
std::string myEnumStr = ss.str();

//Directly to stdout
std::cout << State::FAULT << std::endl;

//to a string
std::string myStr = State::to_string(State::FAULT);

//from a string
State::State myEnumVal = State::from_string(State::FAULT);

ตามคำจำกัดความต่อไปนี้:

#define SMART_ENUM(enumTypeArg, ...)                                                     \
namespace enumTypeArg {                                                                  \
    __VA_ARGS__;                                                                         \
    std::ostream& operator<<(std::ostream& os, const enumTypeArg& val) {                 \
            os << swissarmyknife::enums::to_string(#__VA_ARGS__, val);                   \
            return os;                                                                   \
    }                                                                                    \
                                                                                     \
    std::string to_string(const enumTypeArg& val) {                                      \
            return swissarmyknife::enums::to_string(#__VA_ARGS__, val);                  \
    }                                                                                    \
                                                                                     \
    enumTypeArg from_string(const std::string &str) {                                    \
            return swissarmyknife::enums::from_string<enumTypeArg>(#__VA_ARGS__, str);   \
    }                                                                                    \
}                                                                                        \


namespace swissarmyknife { namespace enums {

    static inline std::string to_string(const std::string completeEnumDeclaration, size_t enumVal) throw (std::runtime_error) {
        size_t begin = completeEnumDeclaration.find_first_of('{');
        size_t end = completeEnumDeclaration.find_last_of('}');
        const std::string identifiers = completeEnumDeclaration.substr(begin + 1, end );

        size_t count = 0;
        size_t found = 0;
        do {
            found = identifiers.find_first_of(",}", found+1);

            if (enumVal == count) {
                std::string identifiersSubset = identifiers.substr(0, found);
                size_t beginId = identifiersSubset.find_last_of("{,");
                identifiersSubset = identifiersSubset.substr(beginId+1);
                boost::algorithm::trim(identifiersSubset);
                return identifiersSubset;
            }

            ++count;
        } while (found != std::string::npos);

        throw std::runtime_error("The enum declaration provided doesn't contains this state.");
    }                                                  

    template <typename EnumType>
    static inline EnumType from_string(const std::string completeEnumDeclaration, const std::string &enumStr) throw (std::runtime_error) {
        size_t begin = completeEnumDeclaration.find_first_of('{');
        size_t end = completeEnumDeclaration.find_last_of('}');
        const std::string identifiers = completeEnumDeclaration.substr(begin + 1, end );

        size_t count = 0;
        size_t found = 0;
        do {
            found = identifiers.find_first_of(",}", found+1);

            std::string identifiersSubset = identifiers.substr(0, found);
            size_t beginId = identifiersSubset.find_last_of("{,");
            identifiersSubset = identifiersSubset.substr(beginId+1);
            boost::algorithm::trim(identifiersSubset);

            if (identifiersSubset == enumStr) {
                return static_cast<EnumType>(count);
            }

            ++count;
        } while (found != std::string::npos);

        throw std::runtime_error("No valid enum value for the provided string");
    }                      

}}

เมื่อใดที่ฉันต้องการการสนับสนุนสำหรับ sparse enum และเมื่อฉันมีเวลามากขึ้นฉันจะปรับปรุงการใช้งานto_stringและfrom_stringด้วย boost :: xpressive แต่สิ่งนี้จะเสียค่าใช้จ่ายในการรวบรวมเนื่องจากการเทมเพลตที่สำคัญและการดำเนินการที่สร้างขึ้นคือ น่าจะใหญ่กว่าจริงๆ แต่สิ่งนี้มีข้อได้เปรียบที่จะสามารถอ่านและดูแลรักษาได้มากกว่ารหัสการจัดการสตริงด้วยตนเองที่น่าเกลียดนี้ : ง

มิฉะนั้นฉันมักจะใช้ boost :: bimap เพื่อทำการแมปดังกล่าวระหว่างค่า enums และสตริง แต่ต้องได้รับการดูแลด้วยตนเอง

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

std::ostream& operator<<(std::ostream& os, provenance_wrapper::CaptureState cs)
{
#define HANDLE(x) case x: os << #x; break;
    switch (cs) {
    HANDLE(CaptureState::UNUSED)
    HANDLE(CaptureState::ACTIVE)
    HANDLE(CaptureState::CLOSED)
    }
    return os;
#undef HANDLE
}