How to easily map c enums to strings

Question

I have a bunch of enum types in some library header files that I m using  and I want to have a way of converting enum values to user strings - and vice-versa    RTTI won t do it for me  because the  user strings  need to be a bit more readable than the enumerations   A brute force solution would be a bunch of functions like this  but I feel that s a bit too C-like   enum MyEnum  VAL1  VAL2 VAL3    String getStringFromEnum MyEnum e      switch e       case VAL1  return  Value 1     case VAL2  return  Value 2     case VAL1  return  Value 3     default  throw Exception  Bad MyEnum            I have a gut feeling that there s an elegant solution using templates  but I can t quite get my head round it yet   UPDATE  Thanks for suggestions - I should have made clear that the enums are defined in a third-party library header  so I don t want to have to change the definition of them   My gut feeling now is to avoid templates and do something like this   char   MyGetValue int v  char  tmp      implementation is trivial   define ENUM MAP type  strings  char   getStringValue const type  amp T          return MyGetValue  int T  strings           enum eee  AA BB CC   - exists in library header file    enum fff  DD GG HH     ENUM MAP eee  AA BB CC   ENUM MAP fff  DD GG HH       To use         eee e      fff f      std  cout lt  lt  getStringValue e       std  cout lt  lt  getStringValue f

User · Answer

I recently had the same issue with a vendor library (Fincad). Fortunately, the vendor provided xml doucumentation for all the enums. I ended up generating a map for each enum type and providing a lookup function for each enum. This technique also allows you to intercept a lookup outside the range of the enum.

I'm sure swig could do something similar for you, but I'm happy to provide the code generation utils which are written in ruby.

Here is a sample of the code:

std::map<std::string, switches::FCSW2::type> init_FCSW2_map() {
        std::map<std::string, switches::FCSW2::type> ans;
        ans["Act365Fixed"] = FCSW2::Act365Fixed;
        ans["actual/365 (fixed)"] = FCSW2::Act365Fixed;
        ans["Act360"] = FCSW2::Act360;
        ans["actual/360"] = FCSW2::Act360;
        ans["Act365Act"] = FCSW2::Act365Act;
        ans["actual/365 (actual)"] = FCSW2::Act365Act;
        ans["ISDA30360"] = FCSW2::ISDA30360;
        ans["30/360 (ISDA)"] = FCSW2::ISDA30360;
        ans["ISMA30E360"] = FCSW2::ISMA30E360;
        ans["30E/360 (30/360 ISMA)"] = FCSW2::ISMA30E360;
        return ans;
}
switches::FCSW2::type FCSW2_lookup(const char* fincad_switch) {
        static std::map<std::string, switches::FCSW2::type> switch_map = init_FCSW2_map();
        std::map<std::string, switches::FCSW2::type>::iterator it = switch_map.find(fincad_switch);
        if(it != switch_map.end()) {
                return it->second;
        } else {
                throw FCSwitchLookupError("Bad Match: FCSW2");
        }
}

Seems like you want to go the other way (enum to string, rather than string to enum), but this should be trivial to reverse.

-Whit

User · Answer

I use this solution which I reproduce below    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  lt  kMax  k                  printf   s n   kConstStr k               return 0

User · Answer

I just wanted to show this possible elegant solution using macros  This doesn t solve the problem but I think it is a good way to rethik about the problem    define MY LIST X  X value1   X value2   X value3   enum eMyEnum           MY LIST PLAIN          const char  szMyEnum               MY LIST STRINGY           int main int argc  char  argv       std  cout  lt  lt  szMyEnum value1   lt  lt  value1  lt  lt      lt  lt   szMyEnum value2   lt  lt  value2  lt  lt  std  endl   return 0      ----  EDIT  ----  After some internet research and some own experements I came to the following solution     this is the enum definition  define COLOR LIST X      X  RED      21           X  GREEN             X  BLUE              X  PURPLE    242           X  ORANGE            X  YELLOW      these are the macros  define enumfunc enums value  enums   define enumfunc2 enums value  enums value   define ENUM2SWITCHCASE enums  case enums   return  enums    define AUTOENUM enumname listname  enum enumname listname enumfunc2     define ENUM2STRTABLE funname listname  char  funname int val   switch val   listname ENUM2SWITCHCASE  default  return  undef      define ENUM2STRUCTINFO spacename listname  namespace spacename   int values      listname enumfunc   int N   sizeof values  sizeof int  ENUM2STRTABLE enum2str listname       here the enum and the string enum map table are generated AUTOENUM testenum COLOR LIST  ENUM2STRTABLE testfunenum COLOR LIST  ENUM2STRUCTINFO colorinfo COLOR LIST   colorinfo structur  int values    int N  char   enum2str int       debug macros  define str a   a  define xstr a  str a    int main  int argc  char   argv     testenum x   YELLOW  std  cout  lt  lt  testfunenum GREEN   lt  lt         lt  lt  testfunenum PURPLE   lt  lt  PURPLE  lt  lt        lt  lt  testfunenum x    for  int i 0 i lt  colorinfo  N i    std  cout  lt  lt  std  endl  lt  lt  colorinfo  values i   lt  lt        lt  lt  colorinfo  enum2str colorinfo  values i       return EXIT SUCCESS      I just wanted to post it maybe someone could find this solution useful  There is no need of templates classes no need of c  11 and no need of boost so this could also be used for simple C   ---- EDIT2 ----  the information table can produce some problems when using more than 2 enums  compiler problem   The following workaround worked    define ENUM2STRUCTINFO spacename listname  namespace spacename   int spacename     values      listname enumfunc   int spacename     N   sizeof spacename     values  sizeof int  ENUM2STRTABLE spacename     enum2str listname

User · Answer

I d be tempted to have a map m - and embedd this into the enum   setup with m MyEnum VAL1     Value 1    and all is done

User · Answer

Auto-generate one form from another   Source   enum     VALUE1     value 1      VALUE2     value 2         Generated   const char  enum2str          value 1      VALUE1       value 2      VALUE2         If enum values are large then a generated form could use unordered map lt   or templates as suggested by Constantin   Source   enum State    state0   0     state 0      state1   1     state 1      state2   2     state 2      state3   4     state 3       state16   0x10000     state 16         Generated   template  lt State n gt  struct enum2str   static const char   const value     template  lt State n gt  const char   const enum2str lt n gt   value    error    template  lt  gt  struct enum2str lt state0 gt    static const char   const value     const char   const enum2str lt state0 gt   value    state 0     Example    include  lt iostream gt   int main       std  cout  lt  lt  enum2str lt state16 gt   value  lt  lt  std  endl    return 0

User · Answer

MSalters solution is a good one but basically re-implements boost  assign  map list of  If you have boost  you can use it directly    include  lt boost assign list of hpp gt   include  lt boost unordered map hpp gt   include  lt iostream gt   using boost  assign  map list of   enum eee   AA BB CC     const boost  unordered map lt eee const char  gt  eeeToString   map list of      AA   AA        BB   BB        CC   CC     int main         std  cout  lt  lt    enum AA      lt  lt  eeeToString at AA   lt  lt  std  endl      return 0

User · Answer

I suggest a mix of using X-macros are the best solution and the following template functions   To borrow off marcinkoziukmyopenidcom and extended  enum Colours       define X a  a      include  colours def      undef X     ColoursCount     char const  const colours str           define X a   a      include  colours def      undef X     0     template  lt class T gt  T str2enum  const char     template  lt class T gt  const char  enum2str  T      define STR2ENUM TYPE ARRAY    template  lt  gt    TYPE str2enum lt TYPE gt   const char  str                 for  int i   0  i  lt   sizeof ARRAY  sizeof ARRAY 0     i               if   strcmp  ARRAY i   str                   return TYPE i         return TYPE 0             define ENUM2STR TYPE ARRAY    template  lt  gt    const char  enum2str lt TYPE gt   TYPE v                 return ARRAY v             define ENUMANDSTR TYPE ARRAY       STR2ENUM TYPE ARRAY        ENUM2STR TYPE ARRAY   ENUMANDSTR Colours colours str    colour def  X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta

User · Answer

If you want the enum names themselves as strings  see this post  Otherwise  a std  map lt MyEnum  char const  gt  will work nicely   No point in copying your string literals to std  strings in the map   For extra syntactic sugar  here s how to write a map init class  The goal is to allow  std  map lt MyEnum  const char  gt  MyMap  map init MyMap       eValue1   A        eValue2   B        eValue3   C       The function template  lt typename T gt  map init T amp   returns a map init helper lt T gt    map init helper lt T gt  stores a T amp   and defines the trivial map init helper amp  operator   typename T  key type const amp   typename T  value type const amp     Returning  this from operator   allows the chaining of operator    like operator lt  lt  on std  ostreams   template lt typename T gt  struct map init helper       T amp  data      map init helper T amp  d    data d         map init helper amp  operator    typename T  key type const amp  key  typename T  mapped type const amp  value                data key    value          return  this            template lt typename T gt  map init helper lt T gt  map init T amp  item        return map init helper lt T gt  item       Since the function and helper class are templated  you can use them for any map  or map-like structure  I e  it can also add entries to std  unordered map  If you don t like writing these helpers  boost  assign offers the same functionality out of the box

User · Answer

If you want the enum names themselves as strings  see this post  Otherwise  a std  map lt MyEnum  char const  gt  will work nicely   No point in copying your string literals to std  strings in the map   For extra syntactic sugar  here s how to write a map init class  The goal is to allow  std  map lt MyEnum  const char  gt  MyMap  map init MyMap       eValue1   A        eValue2   B        eValue3   C       The function template  lt typename T gt  map init T amp   returns a map init helper lt T gt    map init helper lt T gt  stores a T amp   and defines the trivial map init helper amp  operator   typename T  key type const amp   typename T  value type const amp     Returning  this from operator   allows the chaining of operator    like operator lt  lt  on std  ostreams   template lt typename T gt  struct map init helper       T amp  data      map init helper T amp  d    data d         map init helper amp  operator    typename T  key type const amp  key  typename T  mapped type const amp  value                data key    value          return  this            template lt typename T gt  map init helper lt T gt  map init T amp  item        return map init helper lt T gt  item       Since the function and helper class are templated  you can use them for any map  or map-like structure  I e  it can also add entries to std  unordered map  If you don t like writing these helpers  boost  assign offers the same functionality out of the box

User · Answer

I have spent more time researching this topic that I d like to admit  Luckily there are great open source solutions in the wild   These are two great approaches  even if not well known enough  yet    wise enum   Standalone smart enum library for C  11 14 17  It supports all of the standard functionality that you would expect from a smart enum class in C    Limitations  requires at least C  11    Better Enums   Reflective compile-time enum library with clean syntax  in a single header file  and without dependencies  Limitations  based on macros  can t be used inside a class

User · Answer

I know I m late to party  but for everyone else who comes to visit this page  u could try this  it s easier than everything there and makes more sense   namespace texs       typedef std  string Type      Type apple    apple       Type wood    wood

User · Answer

this right old mess is my effort based on bits and peices from SO  The for each would have to be expanded to support more than 20 enum values  Tested it on visual studio 2019 clang and gcc  c  11    define  enum expand arg  arg  define  enum select for each    0   1   2  3  4   5   6  7  8  9  10  11  12  13  14  15  16  17  18  19 N       N  define  enum for each 0  call  arg0 arg1       define  enum for each 1  call  arg0 arg1   call arg0 arg1   define  enum for each 2  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 1  call arg0    VA ARGS      define  enum for each 3  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 2  call arg0    VA ARGS      define  enum for each 4  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 3  call arg0    VA ARGS      define  enum for each 5  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 4  call arg0    VA ARGS      define  enum for each 6  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 5  call arg0    VA ARGS      define  enum for each 7  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 6  call arg0    VA ARGS      define  enum for each 8  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 7  call arg0    VA ARGS      define  enum for each 9  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 8  call arg0    VA ARGS      define  enum for each 10  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 9  call arg0    VA ARGS      define  enum for each 11  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 10  call arg0    VA ARGS      define  enum for each 12  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 11  call arg0    VA ARGS      define  enum for each 13  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 12  call arg0    VA ARGS      define  enum for each 14  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 13  call arg0    VA ARGS      define  enum for each 15  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 14  call arg0    VA ARGS      define  enum for each 16  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 15  call arg0    VA ARGS      define  enum for each 17  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 16  call arg0    VA ARGS      define  enum for each 18  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 17  call arg0    VA ARGS      define  enum for each 19  call  arg0 arg1        call arg   enum expand  enum for each 18  call arg0    VA ARGS      define  enum for each arg              enum expand  enum select for each        VA ARGS           enum for each 19   enum for each 18   enum for each 17   enum for each 16   enum for each 15         enum for each 14   enum for each 13   enum for each 12   enum for each 11   enum for each 10         enum for each 9    enum for each 8    enum for each 7    enum for each 6    enum for each 5          enum for each 4    enum for each 3    enum for each 2    enum for each 1    enum for each 0  arg      VA ARGS       define  enum strip args 1 arg0  arg0  define  enum strip args 2 arg0  arg1  arg0  arg1  define  enum make args         VA ARGS      define  enum elem arity1 1 arg  arg   define  enum elem arity1        enum expand  enum elem arity1 1   VA ARGS     define  enum elem arity2 1 arg0 arg1  arg0   arg1   define  enum elem arity2        enum expand  enum elem arity2 1   VA ARGS      define  enum elem select arity 2  0   1  NAME      NAME  define  enum elem select arity 1       enum expand  enum elem select arity 2   VA ARGS     enum elem arity2  enum elem arity1      define  enum elem select arity enum type       enum expand  enum elem select arity 1   VA ARGS      VA ARGS      define  enum str arity1 1 enum type arg    enum type  arg  arg     define  enum str arity1 enum type       enum expand  enum str arity1 1  enum make args  enum type   enum expand  enum strip args 1   VA ARGS       define  enum str arity2 1 enum type arg value    enum type  arg  arg     define  enum str arity2 enum type        enum expand  enum str arity2 1  enum make args  enum type   enum expand  enum strip args 2   VA ARGS       define  enum str select arity 2  0   1  NAME      NAME  define  enum str select arity 1       enum expand  enum str select arity 2   VA ARGS     enum str arity2  enum str arity1      define  enum str select arity enum type       enum expand  enum str select arity 1   VA ARGS    enum type   VA ARGS      define error code enum enum type       enum class enum type                       enum expand  enum for each  enum elem select arity enum type      VA ARGS              namespace      enum type     detail             template  lt typename gt  struct      enum type     error code                static const std  map lt enum type  const char  gt  enum type     map                             template  lt typename T gt                const std  map lt enum type  const char  gt       enum type     error code lt T gt   enum type     map                        enum expand  enum for each  enum str select arity enum type       VA ARGS                                inline const char  get error code name const enum type amp  value              return      enum type     detail       enum type     error code lt enum type gt   enum type     map find value - gt second            error code enum myenum       one  1        two       which produces the following code  enum class myenum        one   1      two     namespace  myenum detail       template  lt typename gt      struct  myenum error code           static const std  map lt myenum  const char  gt  myenum map             template  lt typename T gt      const std  map lt myenum  const char  gt   myenum error code lt T gt   myenum map               myenum  one   one                myenum  two   two              inline const char  get error code name const myenum amp  value         return  myenum detail   myenum error code lt myenum gt   myenum map find value - gt second       Such a shame the hoops you have to jump though with the preprocessor to do this in one of the most used programming languages in the world

User · Answer

If you want to get string representations of MyEnum variables  then templates won t cut it  Template can be specialized on integral values known at compile-time   However  if that s what you want then try    include  lt iostream gt   enum MyEnum   VAL1  VAL2     template lt MyEnum n gt  struct StrMyEnum       static char const  name     return  Unknown          define STRENUM val  str      template lt  gt  struct StrMyEnum lt val gt          static char const  name     return str       STRENUM VAL1   Value 1    STRENUM VAL2   Value 2     int main       std  cout  lt  lt  StrMyEnum lt VAL2 gt   name        This is verbose  but will catch errors like the one you made in question - your case VAL1 is duplicated

User · Answer

I d be tempted to have a map m - and embedd this into the enum   setup with m MyEnum VAL1     Value 1    and all is done

User · Answer

If you want to get string representations of MyEnum variables  then templates won t cut it  Template can be specialized on integral values known at compile-time   However  if that s what you want then try    include  lt iostream gt   enum MyEnum   VAL1  VAL2     template lt MyEnum n gt  struct StrMyEnum       static char const  name     return  Unknown          define STRENUM val  str      template lt  gt  struct StrMyEnum lt val gt          static char const  name     return str       STRENUM VAL1   Value 1    STRENUM VAL2   Value 2     int main       std  cout  lt  lt  StrMyEnum lt VAL2 gt   name        This is verbose  but will catch errors like the one you made in question - your case VAL1 is duplicated

User · Answer

I remember having answered this elsewhere on StackOverflow  Repeating it here  Basically it s a solution based on variadic macros  and is pretty easy to use    define AWESOME MAKE ENUM name       enum class name     VA ARGS      COUNT     inline std  ostream amp  operator lt  lt  std  ostream amp  os  name value      std  string enumName    name    std  string str      VA ARGS      int len   str length      std  vector lt std  string gt  strings    std  ostringstream temp    for int i   0  i  lt  len  i         if isspace str i    continue            else if str i                      strings push back temp str               temp str std  string                          else temp lt  lt  str i         strings push back temp str       os  lt  lt  enumName  lt  lt        lt  lt  strings static cast lt int gt  value      return os      To use it in your code  simply do    AWESOME MAKE ENUM Animal      DOG      CAT      HORSE    auto dog   Animal  DOG  std  cout lt  lt dog

User · Answer

I recently had the same issue with a vendor library (Fincad). Fortunately, the vendor provided xml doucumentation for all the enums. I ended up generating a map for each enum type and providing a lookup function for each enum. This technique also allows you to intercept a lookup outside the range of the enum.

I'm sure swig could do something similar for you, but I'm happy to provide the code generation utils which are written in ruby.

Here is a sample of the code:

std::map<std::string, switches::FCSW2::type> init_FCSW2_map() {
        std::map<std::string, switches::FCSW2::type> ans;
        ans["Act365Fixed"] = FCSW2::Act365Fixed;
        ans["actual/365 (fixed)"] = FCSW2::Act365Fixed;
        ans["Act360"] = FCSW2::Act360;
        ans["actual/360"] = FCSW2::Act360;
        ans["Act365Act"] = FCSW2::Act365Act;
        ans["actual/365 (actual)"] = FCSW2::Act365Act;
        ans["ISDA30360"] = FCSW2::ISDA30360;
        ans["30/360 (ISDA)"] = FCSW2::ISDA30360;
        ans["ISMA30E360"] = FCSW2::ISMA30E360;
        ans["30E/360 (30/360 ISMA)"] = FCSW2::ISMA30E360;
        return ans;
}
switches::FCSW2::type FCSW2_lookup(const char* fincad_switch) {
        static std::map<std::string, switches::FCSW2::type> switch_map = init_FCSW2_map();
        std::map<std::string, switches::FCSW2::type>::iterator it = switch_map.find(fincad_switch);
        if(it != switch_map.end()) {
                return it->second;
        } else {
                throw FCSwitchLookupError("Bad Match: FCSW2");
        }
}

Seems like you want to go the other way (enum to string, rather than string to enum), but this should be trivial to reverse.

-Whit

User · Answer

I ve required this functionality several times for debugging analyzing code from others  For this  I ve written a Perl script which generates a class with several overloaded toString methods  Each toString method takes an Enum as an argument and returns const char    Of course  the script doesn t parse C   for enums itself  but uses ctags for generating symbol table   The Perl script is here  http   heinitz-it de download enum2string enum2string pl html

User · Answer

I suggest a mix of using X-macros are the best solution and the following template functions   To borrow off marcinkoziukmyopenidcom and extended  enum Colours       define X a  a      include  colours def      undef X     ColoursCount     char const  const colours str           define X a   a      include  colours def      undef X     0     template  lt class T gt  T str2enum  const char     template  lt class T gt  const char  enum2str  T      define STR2ENUM TYPE ARRAY    template  lt  gt    TYPE str2enum lt TYPE gt   const char  str                 for  int i   0  i  lt   sizeof ARRAY  sizeof ARRAY 0     i               if   strcmp  ARRAY i   str                   return TYPE i         return TYPE 0             define ENUM2STR TYPE ARRAY    template  lt  gt    const char  enum2str lt TYPE gt   TYPE v                 return ARRAY v             define ENUMANDSTR TYPE ARRAY       STR2ENUM TYPE ARRAY        ENUM2STR TYPE ARRAY   ENUMANDSTR Colours colours str    colour def  X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta

User · Answer

I d be tempted to have a map m - and embedd this into the enum   setup with m MyEnum VAL1     Value 1    and all is done

User · Answer

I d be tempted to have a map m - and embedd this into the enum   setup with m MyEnum VAL1     Value 1    and all is done

User · Answer

I recently had the same issue with a vendor library (Fincad). Fortunately, the vendor provided xml doucumentation for all the enums. I ended up generating a map for each enum type and providing a lookup function for each enum. This technique also allows you to intercept a lookup outside the range of the enum.

I'm sure swig could do something similar for you, but I'm happy to provide the code generation utils which are written in ruby.

Here is a sample of the code:

std::map<std::string, switches::FCSW2::type> init_FCSW2_map() {
        std::map<std::string, switches::FCSW2::type> ans;
        ans["Act365Fixed"] = FCSW2::Act365Fixed;
        ans["actual/365 (fixed)"] = FCSW2::Act365Fixed;
        ans["Act360"] = FCSW2::Act360;
        ans["actual/360"] = FCSW2::Act360;
        ans["Act365Act"] = FCSW2::Act365Act;
        ans["actual/365 (actual)"] = FCSW2::Act365Act;
        ans["ISDA30360"] = FCSW2::ISDA30360;
        ans["30/360 (ISDA)"] = FCSW2::ISDA30360;
        ans["ISMA30E360"] = FCSW2::ISMA30E360;
        ans["30E/360 (30/360 ISMA)"] = FCSW2::ISMA30E360;
        return ans;
}
switches::FCSW2::type FCSW2_lookup(const char* fincad_switch) {
        static std::map<std::string, switches::FCSW2::type> switch_map = init_FCSW2_map();
        std::map<std::string, switches::FCSW2::type>::iterator it = switch_map.find(fincad_switch);
        if(it != switch_map.end()) {
                return it->second;
        } else {
                throw FCSwitchLookupError("Bad Match: FCSW2");
        }
}

Seems like you want to go the other way (enum to string, rather than string to enum), but this should be trivial to reverse.

-Whit

User · Answer

in the header   enum EFooOptions    FooOptionsA   0  EFooOptionsMin   0  FooOptionsB  FooOptionsC  FooOptionsD  EFooOptionsMax    extern const wchar  FOO OPTIONS EFooOptionsMax     in the  cpp file   const wchar  FOO OPTIONS           L One       L Two       L Three       L Four       Caveat  Don t handle bad array index     But you can easily add a function to verify the enum before getting the string from the array

User · Answer

If you want the enum names themselves as strings  see this post  Otherwise  a std  map lt MyEnum  char const  gt  will work nicely   No point in copying your string literals to std  strings in the map   For extra syntactic sugar  here s how to write a map init class  The goal is to allow  std  map lt MyEnum  const char  gt  MyMap  map init MyMap       eValue1   A        eValue2   B        eValue3   C       The function template  lt typename T gt  map init T amp   returns a map init helper lt T gt    map init helper lt T gt  stores a T amp   and defines the trivial map init helper amp  operator   typename T  key type const amp   typename T  value type const amp     Returning  this from operator   allows the chaining of operator    like operator lt  lt  on std  ostreams   template lt typename T gt  struct map init helper       T amp  data      map init helper T amp  d    data d         map init helper amp  operator    typename T  key type const amp  key  typename T  mapped type const amp  value                data key    value          return  this            template lt typename T gt  map init helper lt T gt  map init T amp  item        return map init helper lt T gt  item       Since the function and helper class are templated  you can use them for any map  or map-like structure  I e  it can also add entries to std  unordered map  If you don t like writing these helpers  boost  assign offers the same functionality out of the box

User · Answer

typedef enum       ERR CODE OK   0      ERR CODE SNAP       ERR CODE NUM   ERR CODE   const char  g err msg ERR CODE NUM             ERR CODE OK       OK          ERR CODE SNAP     Oh  snap         Above is my simple solution  One benefit of it is the  NUM  which controls the size of the message array  it also prevents out of boundary access  if you use it wisely    You can also define a function to get the string   const char  get err msg ERR CODE code        return g err msg code       Further to my solution  I then found the following one quite interesting  It generally solved the sync problem of the above one   Slides here  http   www slideshare net arunksaha touchless-enum-tostring-28684724  Code here  https   github com arunksaha enum to string

User · Answer

Auto-generate one form from another   Source   enum     VALUE1     value 1      VALUE2     value 2         Generated   const char  enum2str          value 1      VALUE1       value 2      VALUE2         If enum values are large then a generated form could use unordered map lt   or templates as suggested by Constantin   Source   enum State    state0   0     state 0      state1   1     state 1      state2   2     state 2      state3   4     state 3       state16   0x10000     state 16         Generated   template  lt State n gt  struct enum2str   static const char   const value     template  lt State n gt  const char   const enum2str lt n gt   value    error    template  lt  gt  struct enum2str lt state0 gt    static const char   const value     const char   const enum2str lt state0 gt   value    state 0     Example    include  lt iostream gt   int main       std  cout  lt  lt  enum2str lt state16 gt   value  lt  lt  std  endl    return 0

User · Answer

I suggest a mix of using X-macros are the best solution and the following template functions   To borrow off marcinkoziukmyopenidcom and extended  enum Colours       define X a  a      include  colours def      undef X     ColoursCount     char const  const colours str           define X a   a      include  colours def      undef X     0     template  lt class T gt  T str2enum  const char     template  lt class T gt  const char  enum2str  T      define STR2ENUM TYPE ARRAY    template  lt  gt    TYPE str2enum lt TYPE gt   const char  str                 for  int i   0  i  lt   sizeof ARRAY  sizeof ARRAY 0     i               if   strcmp  ARRAY i   str                   return TYPE i         return TYPE 0             define ENUM2STR TYPE ARRAY    template  lt  gt    const char  enum2str lt TYPE gt   TYPE v                 return ARRAY v             define ENUMANDSTR TYPE ARRAY       STR2ENUM TYPE ARRAY        ENUM2STR TYPE ARRAY   ENUMANDSTR Colours colours str    colour def  X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta

User · Answer

Your answers inspired me to write some macros myself  My requirements were the following    only write each value of the enum once  so there are no double lists to maintain don t keep the enum values in a separate file that is later  included  so I can write it wherever I want don t replace the enum itself  I still want to have the enum type defined  but in addition to it I want to be able to map every enum name to the corresponding string  to not affect legacy code  the searching should be fast  so preferably no switch-case  for those huge enums   This code creates a classic enum with some values  In addition it creates as std  map which maps each enum value to it s name  i e  map E SUNDAY     E SUNDAY   etc    Ok  here is the code now   EnumUtilsImpl h   map lt int  string gt   amp  operator    map lt int  string gt   amp  dest                                  const pair lt int  string gt   amp  keyValue        dest keyValue first    keyValue second       return dest      define ADD TO MAP name  value  pair lt int  string gt  name   name    EnumUtils h    this is the file you want to include whenever you need to do this stuff  you will use the macros from it    include  EnumUtilsImpl h   define ADD TO ENUM name  value        name value   define MAKE ENUM MAP GLOBAL values  mapName        int   makeMap  mapName    mapName  values ADD TO MAP   return 0          int   makeMapTmp  mapName     makeMap  mapName      define MAKE ENUM MAP values  mapName        mapName  values ADD TO MAP     MyProjectCodeFile h    this is an example of how to use it to create a custom enum    include  EnumUtils h    define MyEnumValues ADD        ADD val1           ADD val2           ADD val3    100         ADD val4     enum MyEnum       MyEnumValues ADD TO ENUM      map lt int  string gt  MyEnumStrings     this is how you initialize it outside any function MAKE ENUM MAP GLOBAL MyEnumValues  MyEnumStrings     void MyInitializationMethod             or you can initialize it inside one of your functions methods     MAKE ENUM MAP MyEnumValues  MyEnumStrings        Cheers

User · Answer

If you want to get string representations of MyEnum variables  then templates won t cut it  Template can be specialized on integral values known at compile-time   However  if that s what you want then try    include  lt iostream gt   enum MyEnum   VAL1  VAL2     template lt MyEnum n gt  struct StrMyEnum       static char const  name     return  Unknown          define STRENUM val  str      template lt  gt  struct StrMyEnum lt val gt          static char const  name     return str       STRENUM VAL1   Value 1    STRENUM VAL2   Value 2     int main       std  cout  lt  lt  StrMyEnum lt VAL2 gt   name        This is verbose  but will catch errors like the one you made in question - your case VAL1 is duplicated

User · Answer

I remember having answered this elsewhere on StackOverflow  Repeating it here  Basically it s a solution based on variadic macros  and is pretty easy to use    define AWESOME MAKE ENUM name       enum class name     VA ARGS      COUNT     inline std  ostream amp  operator lt  lt  std  ostream amp  os  name value      std  string enumName    name    std  string str      VA ARGS      int len   str length      std  vector lt std  string gt  strings    std  ostringstream temp    for int i   0  i  lt  len  i         if isspace str i    continue            else if str i                      strings push back temp str               temp str std  string                          else temp lt  lt  str i         strings push back temp str       os  lt  lt  enumName  lt  lt        lt  lt  strings static cast lt int gt  value      return os      To use it in your code  simply do    AWESOME MAKE ENUM Animal      DOG      CAT      HORSE    auto dog   Animal  DOG  std  cout lt  lt dog

User · Answer

typedef enum       ERR CODE OK   0      ERR CODE SNAP       ERR CODE NUM   ERR CODE   const char  g err msg ERR CODE NUM             ERR CODE OK       OK          ERR CODE SNAP     Oh  snap         Above is my simple solution  One benefit of it is the  NUM  which controls the size of the message array  it also prevents out of boundary access  if you use it wisely    You can also define a function to get the string   const char  get err msg ERR CODE code        return g err msg code       Further to my solution  I then found the following one quite interesting  It generally solved the sync problem of the above one   Slides here  http   www slideshare net arunksaha touchless-enum-tostring-28684724  Code here  https   github com arunksaha enum to string

User · Answer

If you want the enum names themselves as strings  see this post  Otherwise  a std  map lt MyEnum  char const  gt  will work nicely   No point in copying your string literals to std  strings in the map   For extra syntactic sugar  here s how to write a map init class  The goal is to allow  std  map lt MyEnum  const char  gt  MyMap  map init MyMap       eValue1   A        eValue2   B        eValue3   C       The function template  lt typename T gt  map init T amp   returns a map init helper lt T gt    map init helper lt T gt  stores a T amp   and defines the trivial map init helper amp  operator   typename T  key type const amp   typename T  value type const amp     Returning  this from operator   allows the chaining of operator    like operator lt  lt  on std  ostreams   template lt typename T gt  struct map init helper       T amp  data      map init helper T amp  d    data d         map init helper amp  operator    typename T  key type const amp  key  typename T  mapped type const amp  value                data key    value          return  this            template lt typename T gt  map init helper lt T gt  map init T amp  item        return map init helper lt T gt  item       Since the function and helper class are templated  you can use them for any map  or map-like structure  I e  it can also add entries to std  unordered map  If you don t like writing these helpers  boost  assign offers the same functionality out of the box

User · Answer

Auto-generate one form from another   Source   enum     VALUE1     value 1      VALUE2     value 2         Generated   const char  enum2str          value 1      VALUE1       value 2      VALUE2         If enum values are large then a generated form could use unordered map lt   or templates as suggested by Constantin   Source   enum State    state0   0     state 0      state1   1     state 1      state2   2     state 2      state3   4     state 3       state16   0x10000     state 16         Generated   template  lt State n gt  struct enum2str   static const char   const value     template  lt State n gt  const char   const enum2str lt n gt   value    error    template  lt  gt  struct enum2str lt state0 gt    static const char   const value     const char   const enum2str lt state0 gt   value    state 0     Example    include  lt iostream gt   int main       std  cout  lt  lt  enum2str lt state16 gt   value  lt  lt  std  endl    return 0

User · Answer

Your answers inspired me to write some macros myself  My requirements were the following    only write each value of the enum once  so there are no double lists to maintain don t keep the enum values in a separate file that is later  included  so I can write it wherever I want don t replace the enum itself  I still want to have the enum type defined  but in addition to it I want to be able to map every enum name to the corresponding string  to not affect legacy code  the searching should be fast  so preferably no switch-case  for those huge enums   This code creates a classic enum with some values  In addition it creates as std  map which maps each enum value to it s name  i e  map E SUNDAY     E SUNDAY   etc    Ok  here is the code now   EnumUtilsImpl h   map lt int  string gt   amp  operator    map lt int  string gt   amp  dest                                  const pair lt int  string gt   amp  keyValue        dest keyValue first    keyValue second       return dest      define ADD TO MAP name  value  pair lt int  string gt  name   name    EnumUtils h    this is the file you want to include whenever you need to do this stuff  you will use the macros from it    include  EnumUtilsImpl h   define ADD TO ENUM name  value        name value   define MAKE ENUM MAP GLOBAL values  mapName        int   makeMap  mapName    mapName  values ADD TO MAP   return 0          int   makeMapTmp  mapName     makeMap  mapName      define MAKE ENUM MAP values  mapName        mapName  values ADD TO MAP     MyProjectCodeFile h    this is an example of how to use it to create a custom enum    include  EnumUtils h    define MyEnumValues ADD        ADD val1           ADD val2           ADD val3    100         ADD val4     enum MyEnum       MyEnumValues ADD TO ENUM      map lt int  string gt  MyEnumStrings     this is how you initialize it outside any function MAKE ENUM MAP GLOBAL MyEnumValues  MyEnumStrings     void MyInitializationMethod             or you can initialize it inside one of your functions methods     MAKE ENUM MAP MyEnumValues  MyEnumStrings        Cheers

User · Answer

Here is an attempt to get  lt  lt  and    stream operators on enum automatically with an one line macro command only     Definitions    include  lt string gt   include  lt iostream gt   include  lt stdexcept gt   include  lt algorithm gt   include  lt iterator gt   include  lt sstream gt   include  lt vector gt    define MAKE STRING str        str  MAKE STRING1    VA ARGS     define MAKE STRING1  str        str  MAKE STRING2    VA ARGS     define MAKE STRING2  str        str  MAKE STRING3    VA ARGS     define MAKE STRING3  str        str  MAKE STRING4    VA ARGS     define MAKE STRING4  str        str  MAKE STRING5    VA ARGS     define MAKE STRING5  str        str  MAKE STRING6    VA ARGS     define MAKE STRING6  str        str  MAKE STRING7    VA ARGS     define MAKE STRING7  str        str  MAKE STRING8    VA ARGS     define MAKE STRING8  str        str  MAKE STRING9    VA ARGS     define MAKE STRING9  str        str  MAKE STRING10    VA ARGS     define MAKE STRING10  str   str   define MAKE ENUM name       MAKE ENUM    name    VA ARGS     define MAKE CLASS ENUM name       MAKE ENUM  friend  name    VA ARGS      define MAKE ENUM  attribute  name       name     VA ARGS            attribute std  istream amp  operator gt  gt  std  istream amp  is  name amp  e              const char  name  Str       MAKE STRING   VA ARGS                 std  string str            std  istream amp  r   is  gt  gt  str            const size t len   sizeof name  Str  sizeof name  Str 0              const std  vector lt std  string gt  enumStr name  Str  name  Str   len             const std  vector lt std  string gt   const iterator it   std  find enumStr begin    enumStr end    str             if  it    enumStr end                 e   name it - enumStr begin               else               throw std  runtime error  Value       str       is not part of enum   name             return r                 attribute std  ostream amp  operator lt  lt  std  ostream amp  os  const name amp  e              const char  name  Str       MAKE STRING   VA ARGS                 return  os  lt  lt  name  Str e              Usage      Declare global enum enum MAKE ENUM Test3  Item13  Item23  Item33  Itdsdgem43    class Essai   public         Declare enum inside class     enum MAKE CLASS ENUM Test  Item1  Item2  Item3  Itdsdgem4        int main         std  cout  lt  lt  Essai  Item1  lt  lt  std  endl       Essai  Test ddd   Essai  Item1      std  cout  lt  lt  ddd  lt  lt  std  endl       std  istringstream strm  Item2        strm  gt  gt  ddd       std  cout  lt  lt   int  ddd  lt  lt  std  endl      std  cout  lt  lt  ddd  lt  lt  std  endl      Not sure about the limitations of this scheme though    comments are welcome

User · Answer

I use this solution which I reproduce below    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  lt  kMax  k                  printf   s n   kConstStr k               return 0

User · Answer

in the header   enum EFooOptions    FooOptionsA   0  EFooOptionsMin   0  FooOptionsB  FooOptionsC  FooOptionsD  EFooOptionsMax    extern const wchar  FOO OPTIONS EFooOptionsMax     in the  cpp file   const wchar  FOO OPTIONS           L One       L Two       L Three       L Four       Caveat  Don t handle bad array index     But you can easily add a function to verify the enum before getting the string from the array

User · Answer

If you want to get string representations of MyEnum variables  then templates won t cut it  Template can be specialized on integral values known at compile-time   However  if that s what you want then try    include  lt iostream gt   enum MyEnum   VAL1  VAL2     template lt MyEnum n gt  struct StrMyEnum       static char const  name     return  Unknown          define STRENUM val  str      template lt  gt  struct StrMyEnum lt val gt          static char const  name     return str       STRENUM VAL1   Value 1    STRENUM VAL2   Value 2     int main       std  cout  lt  lt  StrMyEnum lt VAL2 gt   name        This is verbose  but will catch errors like the one you made in question - your case VAL1 is duplicated

User · Answer

I just wanted to show this possible elegant solution using macros  This doesn t solve the problem but I think it is a good way to rethik about the problem    define MY LIST X  X value1   X value2   X value3   enum eMyEnum           MY LIST PLAIN          const char  szMyEnum               MY LIST STRINGY           int main int argc  char  argv       std  cout  lt  lt  szMyEnum value1   lt  lt  value1  lt  lt      lt  lt   szMyEnum value2   lt  lt  value2  lt  lt  std  endl   return 0      ----  EDIT  ----  After some internet research and some own experements I came to the following solution     this is the enum definition  define COLOR LIST X      X  RED      21           X  GREEN             X  BLUE              X  PURPLE    242           X  ORANGE            X  YELLOW      these are the macros  define enumfunc enums value  enums   define enumfunc2 enums value  enums value   define ENUM2SWITCHCASE enums  case enums   return  enums    define AUTOENUM enumname listname  enum enumname listname enumfunc2     define ENUM2STRTABLE funname listname  char  funname int val   switch val   listname ENUM2SWITCHCASE  default  return  undef      define ENUM2STRUCTINFO spacename listname  namespace spacename   int values      listname enumfunc   int N   sizeof values  sizeof int  ENUM2STRTABLE enum2str listname       here the enum and the string enum map table are generated AUTOENUM testenum COLOR LIST  ENUM2STRTABLE testfunenum COLOR LIST  ENUM2STRUCTINFO colorinfo COLOR LIST   colorinfo structur  int values    int N  char   enum2str int       debug macros  define str a   a  define xstr a  str a    int main  int argc  char   argv     testenum x   YELLOW  std  cout  lt  lt  testfunenum GREEN   lt  lt         lt  lt  testfunenum PURPLE   lt  lt  PURPLE  lt  lt        lt  lt  testfunenum x    for  int i 0 i lt  colorinfo  N i    std  cout  lt  lt  std  endl  lt  lt  colorinfo  values i   lt  lt        lt  lt  colorinfo  enum2str colorinfo  values i       return EXIT SUCCESS      I just wanted to post it maybe someone could find this solution useful  There is no need of templates classes no need of c  11 and no need of boost so this could also be used for simple C   ---- EDIT2 ----  the information table can produce some problems when using more than 2 enums  compiler problem   The following workaround worked    define ENUM2STRUCTINFO spacename listname  namespace spacename   int spacename     values      listname enumfunc   int spacename     N   sizeof spacename     values  sizeof int  ENUM2STRTABLE spacename     enum2str listname

User · Answer

By using designated array initializers your string array is independent  of the order of elements in the enum  enum Values       Val1      Val2     constexpr string view v name            Val1     quot Value 1 quot        Val2     quot Value 2 quot

User · Answer

in the header   enum EFooOptions    FooOptionsA   0  EFooOptionsMin   0  FooOptionsB  FooOptionsC  FooOptionsD  EFooOptionsMax    extern const wchar  FOO OPTIONS EFooOptionsMax     in the  cpp file   const wchar  FOO OPTIONS           L One       L Two       L Three       L Four       Caveat  Don t handle bad array index     But you can easily add a function to verify the enum before getting the string from the array

User · Answer

See if the following syntax suits you      WeekEnd enumeration enum WeekEnd       Sunday   1      Saturday   7        String support for WeekEnd Begin Enum String  WeekEnd         Enum String  Sunday        Enum String  Saturday      End Enum String      Convert from WeekEnd to string const std  string  amp str   EnumString lt WeekEnd gt   From  Saturday       str should now be  Saturday      Convert from string to WeekEnd WeekEnd w  EnumString lt WeekEnd gt   To  w   Sunday        w should now be Sunday   If it does  then you might want to check out this article  http   www gamedev net reference snippets features cppstringizing

User · Answer

I ve required this functionality several times for debugging analyzing code from others  For this  I ve written a Perl script which generates a class with several overloaded toString methods  Each toString method takes an Enum as an argument and returns const char    Of course  the script doesn t parse C   for enums itself  but uses ctags for generating symbol table   The Perl script is here  http   heinitz-it de download enum2string enum2string pl html

User · Answer

By using designated array initializers your string array is independent  of the order of elements in the enum  enum Values       Val1      Val2     constexpr string view v name            Val1     quot Value 1 quot        Val2     quot Value 2 quot

User · Answer

MSalters solution is a good one but basically re-implements boost  assign  map list of  If you have boost  you can use it directly    include  lt boost assign list of hpp gt   include  lt boost unordered map hpp gt   include  lt iostream gt   using boost  assign  map list of   enum eee   AA BB CC     const boost  unordered map lt eee const char  gt  eeeToString   map list of      AA   AA        BB   BB        CC   CC     int main         std  cout  lt  lt    enum AA      lt  lt  eeeToString at AA   lt  lt  std  endl      return 0

User · Answer

I recently had the same issue with a vendor library (Fincad). Fortunately, the vendor provided xml doucumentation for all the enums. I ended up generating a map for each enum type and providing a lookup function for each enum. This technique also allows you to intercept a lookup outside the range of the enum.

I'm sure swig could do something similar for you, but I'm happy to provide the code generation utils which are written in ruby.

Here is a sample of the code:

std::map<std::string, switches::FCSW2::type> init_FCSW2_map() {
        std::map<std::string, switches::FCSW2::type> ans;
        ans["Act365Fixed"] = FCSW2::Act365Fixed;
        ans["actual/365 (fixed)"] = FCSW2::Act365Fixed;
        ans["Act360"] = FCSW2::Act360;
        ans["actual/360"] = FCSW2::Act360;
        ans["Act365Act"] = FCSW2::Act365Act;
        ans["actual/365 (actual)"] = FCSW2::Act365Act;
        ans["ISDA30360"] = FCSW2::ISDA30360;
        ans["30/360 (ISDA)"] = FCSW2::ISDA30360;
        ans["ISMA30E360"] = FCSW2::ISMA30E360;
        ans["30E/360 (30/360 ISMA)"] = FCSW2::ISMA30E360;
        return ans;
}
switches::FCSW2::type FCSW2_lookup(const char* fincad_switch) {
        static std::map<std::string, switches::FCSW2::type> switch_map = init_FCSW2_map();
        std::map<std::string, switches::FCSW2::type>::iterator it = switch_map.find(fincad_switch);
        if(it != switch_map.end()) {
                return it->second;
        } else {
                throw FCSwitchLookupError("Bad Match: FCSW2");
        }
}

Seems like you want to go the other way (enum to string, rather than string to enum), but this should be trivial to reverse.

-Whit

User · Answer

Here is an attempt to get  lt  lt  and    stream operators on enum automatically with an one line macro command only     Definitions    include  lt string gt   include  lt iostream gt   include  lt stdexcept gt   include  lt algorithm gt   include  lt iterator gt   include  lt sstream gt   include  lt vector gt    define MAKE STRING str        str  MAKE STRING1    VA ARGS     define MAKE STRING1  str        str  MAKE STRING2    VA ARGS     define MAKE STRING2  str        str  MAKE STRING3    VA ARGS     define MAKE STRING3  str        str  MAKE STRING4    VA ARGS     define MAKE STRING4  str        str  MAKE STRING5    VA ARGS     define MAKE STRING5  str        str  MAKE STRING6    VA ARGS     define MAKE STRING6  str        str  MAKE STRING7    VA ARGS     define MAKE STRING7  str        str  MAKE STRING8    VA ARGS     define MAKE STRING8  str        str  MAKE STRING9    VA ARGS     define MAKE STRING9  str        str  MAKE STRING10    VA ARGS     define MAKE STRING10  str   str   define MAKE ENUM name       MAKE ENUM    name    VA ARGS     define MAKE CLASS ENUM name       MAKE ENUM  friend  name    VA ARGS      define MAKE ENUM  attribute  name       name     VA ARGS            attribute std  istream amp  operator gt  gt  std  istream amp  is  name amp  e              const char  name  Str       MAKE STRING   VA ARGS                 std  string str            std  istream amp  r   is  gt  gt  str            const size t len   sizeof name  Str  sizeof name  Str 0              const std  vector lt std  string gt  enumStr name  Str  name  Str   len             const std  vector lt std  string gt   const iterator it   std  find enumStr begin    enumStr end    str             if  it    enumStr end                 e   name it - enumStr begin               else               throw std  runtime error  Value       str       is not part of enum   name             return r                 attribute std  ostream amp  operator lt  lt  std  ostream amp  os  const name amp  e              const char  name  Str       MAKE STRING   VA ARGS                 return  os  lt  lt  name  Str e              Usage      Declare global enum enum MAKE ENUM Test3  Item13  Item23  Item33  Itdsdgem43    class Essai   public         Declare enum inside class     enum MAKE CLASS ENUM Test  Item1  Item2  Item3  Itdsdgem4        int main         std  cout  lt  lt  Essai  Item1  lt  lt  std  endl       Essai  Test ddd   Essai  Item1      std  cout  lt  lt  ddd  lt  lt  std  endl       std  istringstream strm  Item2        strm  gt  gt  ddd       std  cout  lt  lt   int  ddd  lt  lt  std  endl      std  cout  lt  lt  ddd  lt  lt  std  endl      Not sure about the limitations of this scheme though    comments are welcome

User · Answer

I suggest a mix of using X-macros are the best solution and the following template functions   To borrow off marcinkoziukmyopenidcom and extended  enum Colours       define X a  a      include  colours def      undef X     ColoursCount     char const  const colours str           define X a   a      include  colours def      undef X     0     template  lt class T gt  T str2enum  const char     template  lt class T gt  const char  enum2str  T      define STR2ENUM TYPE ARRAY    template  lt  gt    TYPE str2enum lt TYPE gt   const char  str                 for  int i   0  i  lt   sizeof ARRAY  sizeof ARRAY 0     i               if   strcmp  ARRAY i   str                   return TYPE i         return TYPE 0             define ENUM2STR TYPE ARRAY    template  lt  gt    const char  enum2str lt TYPE gt   TYPE v                 return ARRAY v             define ENUMANDSTR TYPE ARRAY       STR2ENUM TYPE ARRAY        ENUM2STR TYPE ARRAY   ENUMANDSTR Colours colours str    colour def  X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta

User · Answer

Auto-generate one form from another   Source   enum     VALUE1     value 1      VALUE2     value 2         Generated   const char  enum2str          value 1      VALUE1       value 2      VALUE2         If enum values are large then a generated form could use unordered map lt   or templates as suggested by Constantin   Source   enum State    state0   0     state 0      state1   1     state 1      state2   2     state 2      state3   4     state 3       state16   0x10000     state 16         Generated   template  lt State n gt  struct enum2str   static const char   const value     template  lt State n gt  const char   const enum2str lt n gt   value    error    template  lt  gt  struct enum2str lt state0 gt    static const char   const value     const char   const enum2str lt state0 gt   value    state 0     Example    include  lt iostream gt   int main       std  cout  lt  lt  enum2str lt state16 gt   value  lt  lt  std  endl    return 0

User · Answer

See if the following syntax suits you      WeekEnd enumeration enum WeekEnd       Sunday   1      Saturday   7        String support for WeekEnd Begin Enum String  WeekEnd         Enum String  Sunday        Enum String  Saturday      End Enum String      Convert from WeekEnd to string const std  string  amp str   EnumString lt WeekEnd gt   From  Saturday       str should now be  Saturday      Convert from string to WeekEnd WeekEnd w  EnumString lt WeekEnd gt   To  w   Sunday        w should now be Sunday   If it does  then you might want to check out this article  http   www gamedev net reference snippets features cppstringizing

User · Answer

MSalters solution is a good one but basically re-implements boost  assign  map list of  If you have boost  you can use it directly    include  lt boost assign list of hpp gt   include  lt boost unordered map hpp gt   include  lt iostream gt   using boost  assign  map list of   enum eee   AA BB CC     const boost  unordered map lt eee const char  gt  eeeToString   map list of      AA   AA        BB   BB        CC   CC     int main         std  cout  lt  lt    enum AA      lt  lt  eeeToString at AA   lt  lt  std  endl      return 0

User · Answer

I have spent more time researching this topic that I d like to admit  Luckily there are great open source solutions in the wild   These are two great approaches  even if not well known enough  yet    wise enum   Standalone smart enum library for C  11 14 17  It supports all of the standard functionality that you would expect from a smart enum class in C    Limitations  requires at least C  11    Better Enums   Reflective compile-time enum library with clean syntax  in a single header file  and without dependencies  Limitations  based on macros  can t be used inside a class

User · Answer

in the header   enum EFooOptions    FooOptionsA   0  EFooOptionsMin   0  FooOptionsB  FooOptionsC  FooOptionsD  EFooOptionsMax    extern const wchar  FOO OPTIONS EFooOptionsMax     in the  cpp file   const wchar  FOO OPTIONS           L One       L Two       L Three       L Four       Caveat  Don t handle bad array index     But you can easily add a function to verify the enum before getting the string from the array

User · Answer

MSalters solution is a good one but basically re-implements boost  assign  map list of  If you have boost  you can use it directly    include  lt boost assign list of hpp gt   include  lt boost unordered map hpp gt   include  lt iostream gt   using boost  assign  map list of   enum eee   AA BB CC     const boost  unordered map lt eee const char  gt  eeeToString   map list of      AA   AA        BB   BB        CC   CC     int main         std  cout  lt  lt    enum AA      lt  lt  eeeToString at AA   lt  lt  std  endl      return 0

User · Answer

this right old mess is my effort based on bits and peices from SO  The for each would have to be expanded to support more than 20 enum values  Tested it on visual studio 2019 clang and gcc  c  11    define  enum expand arg  arg  define  enum select for each    0   1   2  3  4   5   6  7  8  9  10  11  12  13  14  15  16  17  18  19 N       N  define  enum for each 0  call  arg0 arg1       define  enum for each 1  call  arg0 arg1   call arg0 arg1   define  enum for each 2  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 1  call arg0    VA ARGS      define  enum for each 3  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 2  call arg0    VA ARGS      define  enum for each 4  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 3  call arg0    VA ARGS      define  enum for each 5  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 4  call arg0    VA ARGS      define  enum for each 6  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 5  call arg0    VA ARGS      define  enum for each 7  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 6  call arg0    VA ARGS      define  enum for each 8  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 7  call arg0    VA ARGS      define  enum for each 9  call  arg0 arg1        call arg0 arg1    enum expand  enum for each 8  call arg0    VA ARGS      define  enum for each 10  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 9  call arg0    VA ARGS      define  enum for each 11  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 10  call arg0    VA ARGS      define  enum for each 12  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 11  call arg0    VA ARGS      define  enum for each 13  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 12  call arg0    VA ARGS      define  enum for each 14  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 13  call arg0    VA ARGS      define  enum for each 15  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 14  call arg0    VA ARGS      define  enum for each 16  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 15  call arg0    VA ARGS      define  enum for each 17  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 16  call arg0    VA ARGS      define  enum for each 18  call  arg0 arg1        call arg0 arg1   enum expand  enum for each 17  call arg0    VA ARGS      define  enum for each 19  call  arg0 arg1        call arg   enum expand  enum for each 18  call arg0    VA ARGS      define  enum for each arg              enum expand  enum select for each        VA ARGS           enum for each 19   enum for each 18   enum for each 17   enum for each 16   enum for each 15         enum for each 14   enum for each 13   enum for each 12   enum for each 11   enum for each 10         enum for each 9    enum for each 8    enum for each 7    enum for each 6    enum for each 5          enum for each 4    enum for each 3    enum for each 2    enum for each 1    enum for each 0  arg      VA ARGS       define  enum strip args 1 arg0  arg0  define  enum strip args 2 arg0  arg1  arg0  arg1  define  enum make args         VA ARGS      define  enum elem arity1 1 arg  arg   define  enum elem arity1        enum expand  enum elem arity1 1   VA ARGS     define  enum elem arity2 1 arg0 arg1  arg0   arg1   define  enum elem arity2        enum expand  enum elem arity2 1   VA ARGS      define  enum elem select arity 2  0   1  NAME      NAME  define  enum elem select arity 1       enum expand  enum elem select arity 2   VA ARGS     enum elem arity2  enum elem arity1      define  enum elem select arity enum type       enum expand  enum elem select arity 1   VA ARGS      VA ARGS      define  enum str arity1 1 enum type arg    enum type  arg  arg     define  enum str arity1 enum type       enum expand  enum str arity1 1  enum make args  enum type   enum expand  enum strip args 1   VA ARGS       define  enum str arity2 1 enum type arg value    enum type  arg  arg     define  enum str arity2 enum type        enum expand  enum str arity2 1  enum make args  enum type   enum expand  enum strip args 2   VA ARGS       define  enum str select arity 2  0   1  NAME      NAME  define  enum str select arity 1       enum expand  enum str select arity 2   VA ARGS     enum str arity2  enum str arity1      define  enum str select arity enum type       enum expand  enum str select arity 1   VA ARGS    enum type   VA ARGS      define error code enum enum type       enum class enum type                       enum expand  enum for each  enum elem select arity enum type      VA ARGS              namespace      enum type     detail             template  lt typename gt  struct      enum type     error code                static const std  map lt enum type  const char  gt  enum type     map                             template  lt typename T gt                const std  map lt enum type  const char  gt       enum type     error code lt T gt   enum type     map                        enum expand  enum for each  enum str select arity enum type       VA ARGS                                inline const char  get error code name const enum type amp  value              return      enum type     detail       enum type     error code lt enum type gt   enum type     map find value - gt second            error code enum myenum       one  1        two       which produces the following code  enum class myenum        one   1      two     namespace  myenum detail       template  lt typename gt      struct  myenum error code           static const std  map lt myenum  const char  gt  myenum map             template  lt typename T gt      const std  map lt myenum  const char  gt   myenum error code lt T gt   myenum map               myenum  one   one                myenum  two   two              inline const char  get error code name const myenum amp  value         return  myenum detail   myenum error code lt myenum gt   myenum map find value - gt second       Such a shame the hoops you have to jump though with the preprocessor to do this in one of the most used programming languages in the world

User · Answer

I know I m late to party  but for everyone else who comes to visit this page  u could try this  it s easier than everything there and makes more sense   namespace texs       typedef std  string Type      Type apple    apple       Type wood    wood

[c++] How to easily map c++ enums to strings

Examples related to c++

Examples related to templates

Examples related to enums