İşte yapmaya çalıştığım şey:

typedef enum { ONE, TWO, THREE } Numbers;

Aşağıdakine benzer bir geçiş durumu yapacak bir işlev yazmaya çalışıyorum:

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

Her durumda tanımlamak yerine, yukarıda yapmaya çalıştığım gibi enum değişkenini kullanarak onu ayarlamanın bir yolu var mı?

Yerleşik bir çözüm yok. En kolay yol, char*numaralandırmanın int değerinin o numaralamanın açıklayıcı adını içeren bir dizeye dizin oluşturduğu bir dizidir. enumBazı inteşlemelerin dizi tabanlı bir eşlemeyi kullanışsız hale getirecek kadar yüksek olduğu bir seyrek (0'da başlamayan veya numaralandırmada boşlukları olan) varsa, bunun yerine bir karma tablo kullanabilirsiniz.

Bir şeyi hem bir C tanımlayıcısı hem de bir dizge yapma tekniği ?burada kullanılabilir.

Her zamanki gibi, bu tür önişlemci malzemelerinde, önişlemci parçasını yazmak ve anlamak zor olabilir ve makroları diğer makrolara aktarmayı içerir ve # ve ## operatörlerini kullanmayı içerir, ancak kullanmak gerçekten kolaydır. Bu stili, aynı listeyi iki kez tutmanın gerçekten zahmetli olabileceği uzun numaralandırmalar için çok yararlı buluyorum.

Fabrika kodu - yalnızca bir kez yazılır, genellikle başlıkta gizlenir:

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

Fabrika kullanılmış

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)

Teknik, XX makrolarının daha fazla argüman kabul etmesini sağlayacak şekilde kolayca genişletilebilir ve bu örnekte sağladığım üçe benzer şekilde, farklı ihtiyaçlar için XX yerine başka makrolar da hazırlayabilirsiniz.

#İnclude / #define / #undef kullanarak X-Makrolarla karşılaştırma

Bu, diğerlerinin bahsettiği X-Macros'a benzer olsa da, bu çözümün #undefing hiçbir şey gerektirmediği için daha zarif olduğunu düşünüyorum, bu da karmaşık şeylerin çoğunu gizlemenize olanak tanıyan fabrikada başlık dosyası - başlık dosyası yeni bir enum tanımlamanız gerektiğinde hiç dokunmadığınız bir şeydir, bu nedenle yeni enum tanımı çok daha kısa ve daha temizdir.

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

Bunu yapmanın kesinlikle bir yolu var - X () makrolarını kullanın . Bu makrolar, kaynak veri listesinden numaralandırmalar, diziler ve kod blokları oluşturmak için C ön işlemcisini kullanır. Yalnızca X () makrosunu içeren #define öğesine yeni öğeler eklemeniz gerekir. Switch ifadesi otomatik olarak genişler.

Örneğiniz şu şekilde yazılabilir:

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

Daha verimli yollar vardır (örn. Bir dizgi dizisi ve enum indeksi oluşturmak için X Makrolarını kullanmak), ancak bu en basit demodur.

Birkaç sağlam cevabınız olduğunu biliyorum, ancak C ön işlemcisindeki # işlecini biliyor musunuz?

Bunu yapmanıza izin verir:

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

Sık sık ihtiyacım olmasına rağmen C veya C ++ bu işlevi sağlamaz.

Aşağıdaki kod çalışır, ancak en iyisi seyrek olmayan numaralandırmalar için uygundur.

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

Seyrek olmayan derken, formda değil demek istiyorum

typedef enum { ONE, FOUR_THOUSAND = 4000 } Numbers;

çünkü içinde büyük boşluklar var.

Bu yöntemin avantajı, numaralandırmaların ve dizelerin tanımlarını yan yana koymasıdır; bir işlevde switch deyimine sahip olmak onlara öncülük eder. Bu, birini diğeri olmadan değiştirme olasılığınızın daha düşük olduğu anlamına gelir.

ÖPÜCÜK. Numaralandırmalarınızla her türlü diğer anahtar / durum işlerini yapacaksınız, öyleyse yazdırma neden farklı olsun? Bir vakayı unutabileceğiniz yaklaşık 100 başka yer olduğunu düşündüğünüzde, baskı rutininizde bir vakayı unutmak çok büyük bir sorun değildir. Sadece ayrıntılı olmayan durum eşleşmeleri konusunda uyarı verecek olan -Wall'ı derleyin. "Varsayılan" seçeneğini kullanmayın çünkü bu, anahtarı kapsamlı hale getirir ve uyarılar almazsınız. Bunun yerine, anahtarın çıkmasına izin verin ve varsayılan durumla şu şekilde ilgilenin ...

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

C ++ numaralandırmalarını dizelere dönüştürmeyi deneyin . Comments enum ürün keyfi değerlere sahip olduğunda sorunu çözmek iyileştirmeler var.

Boost :: ön işlemcisinin kullanılması , aşağıdaki gibi zarif bir çözümü mümkün kılar:

1.Adım: başlık dosyasını ekleyin:

#include "EnumUtilities.h"

Adım 2: Numaralandırma nesnesini aşağıdaki sözdizimi ile bildirin:

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

3. Adım: Verilerinizi kullanın:

Eleman sayısını almak:

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

İlişkili dizeyi almak:

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;

İlişkili dizeden enum değerini alma:

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;

Ekstra dosya içermeyen, temiz ve kompakt görünüyor. EnumUtilities.h içinde yazdığım kod şu:

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

Bazı sınırlamalar vardır, yani boost :: preprocessor olanları. Bu durumda, sabitlerin listesi 64 öğeden büyük olamaz.

Aynı mantığı takip ederek, seyrek enum oluşturmayı da düşünebilirsiniz:

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

Bu durumda sözdizimi şöyledir:

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

Kullanım yukarıdakiyle benzerdir (eksi eName ## 2Enum işlevi, önceki sözdiziminden çıkarım yapmayı deneyebilirsiniz).

Mac ve linux üzerinde test ettim, ancak boost :: preprocessor'ın tam olarak taşınabilir olmayabileceğini unutmayın.

Buradaki bazı teknikleri birleştirerek en basit formu buldum:

#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 kullanıyorsanız, şunları kullanmak mümkündür:

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

O zaman örneğin arayın

enum_to_string_map[enum1]

Mu Dynamics Araştırma Laboratuvarları - Blog Arşivi'ndeki fikirlere göz atın . Bunu bu yılın başlarında buldum - tam olarak karşılaştığım bağlamı unutuyorum - ve onu bu koda uyarladım. Ön tarafa bir E eklemenin yararlarını tartışabiliriz; ele alınan özel soruna uygulanabilir ancak genel bir çözümün parçası değildir. Bunu daha sonra istersem diye ilginç kod parçalarını sakladığım 'vinyetler' klasörümde sakladım. O sırada bu fikrin nereden geldiğine dair bir not tutmadığımı söylemekten utanıyorum.

Üstbilgi: 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 */

Örnek kaynak:

/*
@(#)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 ön işlemcisinin dünyanın en temiz kullanımı olması zorunlu değildir - ancak materyalin birden çok kez yazılmasını engeller.

Hem C tanımlayıcısı hem de dizgi yapmak

Enum dizini 0 tabanlıysa, adları bir char * dizisine koyabilir ve enum değeriyle dizine ekleyebilirsiniz.

#define stringify( name ) # name

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

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

Bu yöntemle ilgili daha fazla tartışma

Yeni gelenler için önişlemci yönergesi püf noktaları

Ben basit bir şablon sınıfı oluşturduk streamable_enumkullandığı operatörleri akışı olduğunu <<ve >>ve dayanmaktadır 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

Kullanım:

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

Aşağıdaki özelliklere sahip makroları kullanan bir çözüm:

1. numaralandırmanın her bir değerini yalnızca bir kez yazın, böylece sürdürülecek çift liste kalmaz

2. enum değerlerini daha sonra #included olacak şekilde ayrı bir dosyada tutmayın, böylece istediğim yere yazabilirim

3. numaralandırmanın kendisini değiştirmeyin, yine de enum türünün tanımlanmasını istiyorum, ancak buna ek olarak her bir enum adını karşılık gelen dizeyle eşleyebilmek istiyorum (eski kodu etkilememek için)

4. arama hızlı olmalıdır, bu nedenle bu büyük numaralandırmalar için tercihen geçiş durumu olmamalıdır

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

Yapıları ve sınıfları uyarlamak için Boost.Fusion gibi bir çözümün güzel olacağını düşündüm, hatta bir noktada numaralandırmaları füzyon dizisi olarak kullanmak için bile vardı.

Bu yüzden, numaralandırmaları yazdırmak üzere kodu oluşturmak için sadece bazı küçük makrolar yaptım. Bu mükemmel değildir ve Boost.Fusion tarafından oluşturulan standart kod ile görülecek hiçbir şey yoktur, ancak Boost Fusion makroları gibi kullanılabilir. Boost.Fusion'ın, yapı üyelerinin adlarını yazdırmaya izin veren bu altyapıya entegre olması için ihtiyaç duyduğu türleri gerçekten oluşturmak istiyorum, ancak bu daha sonra gerçekleşecek, şimdilik sadece makrolar:

#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

Aşağıdaki eski cevap oldukça kötü, lütfen bunu kullanmayın. :)

Eski cevap:

Enums bildirimi sözdizimini çok fazla değiştirmeden bu sorunu çözen bir yol arıyordum. Dizgeli bir enum bildiriminden bir dizge almak için önişlemciyi kullanan bir çözüme geldim.

Seyrek olmayan numaralandırmaları şu şekilde tanımlayabilirim:

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

Ve onlarla farklı şekillerde etkileşim kurabilirim:

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

Aşağıdaki tanımlara göre:

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

}}

Seyrek enum için desteğe ihtiyacım olduğunda ve daha fazla zamanım olduğunda to_string ve from_string uygulamalarını boost :: xpressive ile geliştireceğim, ancak bu, gerçekleştirilen önemli şablonlama ve oluşturulan yürütülebilir dosya nedeniyle derleme süresine mal olacak gerçekten daha büyük olması muhtemel. Ancak bunun avantajı, bu çirkin manuel dize işleme kodundan daha okunabilir ve bakımı yapılabilir.: D

Aksi takdirde, enums değeri ve string arasında bu tür eşleştirmeleri gerçekleştirmek için her zaman boost :: bimap kullandım, ancak manuel olarak bakımı gerekiyor.

Tüm olağan nedenlerden dolayı makroları kullanmamayı tercih ettiğim için, enum bildirim makrosunu serbest tutma avantajına sahip daha sınırlı bir makro çözümü kullandım. Dezavantajları, her bir numaralandırma için makro tanımını kopyalayıp yapıştırmak ve numaralandırmaya değer eklerken açıkça bir makro çağrısı eklemek zorunda kalmayı içerir.

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
}