Is there a simple way to convert C enum to string

Question

Suppose we have some named enums   enum MyEnum         FOO        BAR   0x50      What I googled for is a script  any language  that scans all the headers in my project and generates a header with one function per enum   char  enum to string MyEnum t     And a implementation with something like this   char  enum to string MyEnum t         switch t            case FOO              return  FOO            case BAR              return  BAR            default              return  INVALID ENUM                The gotcha is really with typedefed enums  and unnamed C style enums  Does anybody know something for this   EDIT  The solution should not modify my source  except for the generated functions  The enums are in an API  so using the solutions proposed until now is just not an option

User · Answer

The following ruby script attempts to parse the headers and builts the required sources alongside the original headers.

#! /usr/bin/env ruby

# Let's "parse" the headers
# Note that using a regular expression is rather fragile
# and may break on some inputs

GLOBS = [
  "toto/*.h",
  "tutu/*.h",
  "tutu/*.hxx"
]

enums = {}
GLOBS.each { |glob|
  Dir[glob].each { |header|
    enums[header] = File.open(header, 'rb') { |f|
      f.read
    }.scan(/enum\s+(\w+)\s+\{\s*([^}]+?)\s*\}/m).collect { |enum_name, enum_key_and_values|
      [
        enum_name, enum_key_and_values.split(/\s*,\s*/).collect { |enum_key_and_value|
          enum_key_and_value.split(/\s*=\s*/).first
        }
      ]
    }
  }
}


# Now we build a .h and .cpp alongside the parsed headers
# using the template engine provided with ruby
require 'erb'

template_h = ERB.new <<-EOS
#ifndef <%= enum_name %>_to_string_h_
#define <%= enum_name %>_to_string_h_ 1

#include "<%= header %>"
char* enum_to_string(<%= enum_name %> e);

#endif
EOS

template_cpp = ERB.new <<-EOS
#include "<%= enum_name %>_to_string.h"

char* enum_to_string(<%= enum_name %> e)
{
  switch (e)
  {<% enum_keys.each do |enum_key| %>
    case <%= enum_key %>: return "<%= enum_key %>";<% end %>
    default: return "INVALID <%= enum_name %> VALUE";
  }
}
EOS

enums.each { |header, enum_name_and_keys|
  enum_name_and_keys.each { |enum_name, enum_keys|
    File.open("#{File.dirname(header)}/#{enum_name}_to_string.h", 'wb') { |built_h|
      built_h.write(template_h.result(binding))
    }

    File.open("#{File.dirname(header)}/#{enum_name}_to_string.cpp", 'wb') { |built_cpp|
      built_cpp.write(template_cpp.result(binding))
    }
  }
}

Using regular expressions makes this "parser" quite fragile, it may not be able to handle your specific headers gracefully.

Let's say you have a header toto/a.h, containing definitions for enums MyEnum and MyEnum2. The script will build:

toto/MyEnum_to_string.h
toto/MyEnum_to_string.cpp
toto/MyEnum2_to_string.h
toto/MyEnum2_to_string.cpp

More robust solutions would be:

Build all sources defining enums and their operations from another source. This means you'll define your enums in a XML/YML/whatever file which is much easier to parse than C/C++.
Use a real compiler such as suggested by Avdi.
Use preprocessor macros with or without templates.

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

That s pretty much the only way it can be done  an array of string could work also    The problem is  once a C program is compiled  the binary value of the enum is all that is used  and the name is gone

User · Answer

define stringify  name     name  enum MyEnum       ENUMVAL1       stuff     stringify EnumName  ENUMVAL1       Returns MyEnum  ENUMVAL1   Further discussion on this method   Preprocessor directive tricks for newcomers

User · Answer

What I tend to do is create a C array with the names in the same order and position as the enum values   eg   enum colours   red  green  blue    const char  colour names        red    green    blue       then you can use the array in places where you want a human-readable value  eg  colours mycolour   red  cout  lt  lt   the colour is   lt  lt  colour names mycolour     You could experiment a little with the stringizing operator  see   in your preprocessor reference  that will do what you want  in some circumstances- eg    define printword XX  cout  lt  lt   XX  printword red     will print  red  to stdout  Unfortunately it won t work for a variable  as you ll get the variable name printed out

User · Answer

I do this with separate side-by-side enum wrapper classes which are generated with macros  There are several advantages    Can generate them for enums I don t define  eg  OS platform header enums  Can incorporate range checking into the wrapper class Can do  smarter  formatting with bit field enums   The downside  of course  is that I need to duplicate the enum values in the formatter classes  and I don t have any script to generate them  Other than that  though  it seems to work pretty well   Here s an example of an enum from my codebase  sans all the framework code which implements the macros and templates  but you can get the idea   enum EHelpLocation       HELP LOCATION UNKNOWN     0       HELP LOCAL FILE           1       HELP HTML ONLINE          2      class CEnumFormatter EHelpLocation   public CEnumDefaultFormatter lt  EHelpLocation  gt    public      static inline CString FormatEnum  EHelpLocation eValue                 switch   eValue                         ON CASE VALUE RETURN STRING OF VALUE  HELP LOCATION UNKNOWN                ON CASE VALUE RETURN STRING OF VALUE  HELP LOCAL FILE                ON CASE VALUE RETURN STRING OF VALUE  HELP HTML ONLINE            default              return FormatAsNumber  eValue                       DECLARE RANGE CHECK CLASS  EHelpLocation  CRangeInfoSequential lt  HELP HTML ONLINE  gt     typedef ESmartEnum lt  EHelpLocation  HELP LOCATION UNKNOWN  CEnumFormatter EHelpLocation  CRangeInfo EHelpLocation  gt  SEHelpLocation    The idea then is instead of using EHelpLocation  you use SEHelpLocation  everything works the same  but you get range checking and a  Format    method on the enum variable itself  If you need to format a stand-alone value  you can use CEnumFormatter EHelpLocation  FormatEnum        Hope this is helpful  I realize this also doesn t address the original question about a script to actually generate the other class  but I hope the structure helps someone trying to solve the same problem  or write such a script

User · Answer

You could use a reflection library  like Ponder  You register the enums and then you can convert them back and forth with the API   enum class MyEnum       Zero   0      One    1      Two    2     ponder  Enum  declare lt MyEnum gt         value  Zero   MyEnum  Zero       value  One    MyEnum  One       value  Two    MyEnum  Two    ponder  EnumObject zero MyEnum  Zero    zero name       - gt   Zero

User · Answer

You may want to check out GCCXML   Running GCCXML on your sample code produces    lt GCC XML gt     lt Namespace id   1  name      members   3   mangled   Z2     gt     lt Namespace id   2  name  std  context   1  members    mangled   Z3std   gt     lt Enumeration id   3  name  MyEnum  context   1  location  f0 1  file  f0  line  1  gt       lt EnumValue name  FOO  init  0   gt       lt EnumValue name  BAR  init  80   gt     lt  Enumeration gt     lt File id  f0  name  my enum h   gt   lt  GCC XML gt    You could use any language you prefer to pull out the Enumeration and EnumValue tags and generate your desired code

User · Answer

Suma s macro solution is nice  You don t need to have two different macro s  though  C   wil happily include a header twice  Just leave out the include guard   So you d have an foobar h defining just  ENUM Foo  1  ENUM Bar  2    and you would include it like this    define ENUMFACTORY ARGUMENT  foobar h   include  enumfactory h    enumfactory h will do 2  include ENUMFACTORY ARGUMENTs  In the first round  it expands ENUM like Suma s DECLARE ENUM  in the second round ENUM works like DEFINE ENUM   You can include enumfactory h multiple times  too  as long as you pass in different  define s for ENUMFACTORY ARGUMENT

User · Answer

I came across this question when I was looking for a solution to my own problem for printing the  words  of the enumeration in C     I came back to provide a simple solution which answers the presented question as worded   All that s required is to  mirror  the enum list with a vector   enum class genre   Fiction  NonFiction  Periodical  Biography  Children     vector lt string gt genre tbl    Fiction    NonFiction    Periodical    Biography    Children       Because the enum as typed above will do the following by default   Fiction   0 NonFiction   1 Periodical   2 Biography   3 Children   4   This matches the vector positions which makes enum to string conversion pretty straight forward   string s1   genre tbl int genre  fiction      For my problem I created a user defined class called Book with a member called Gen of type genre   The program needed to be able to print the genre as the word   class book        ostream amp  operator lt  lt  ostream amp  os  genre g    return os  lt  lt  genre tbl int g       book b1  b1 Gen   genre 0  cout  lt  lt  b1 Gen    For which  Fiction  will print to screen in this case

User · Answer

Note that your conversion function should ideally be returning a const char     If you can afford to put your enums in their separate header files  you could perhaps do something like this with macros  oh  this will be ugly     include  enum def h   include  colour h   include  enum conv h   include  colour h    Where enum def h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  enum NAME    define ENUM ADD NAME  VALUE  NAME   VALUE   define ENUM END      And enum conv h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  const char    NAME   to string NAME val    switch  val     define ENUM ADD NAME  VALUE  case NAME  return  NAME   define ENUM END default  return  Invalid value         And finally  colour h has   ENUM START colour  ENUM ADD red    0xff0000  ENUM ADD green  0x00ff00  ENUM ADD blue   0x0000ff  ENUM END   And you can use the conversion function as   printf   s   colour to string colour  red      This is ugly  but it s the only way  at the preprocessor level  that lets you define your enum just in a single place in your code  Your code is therefore not prone to errors due to modifications to the enum  Your enum definition and the conversion function will always be in sync  However  I repeat  this is ugly

User · Answer

I just re-invented this wheel today  and thought I d share it   This implementation does not require any changes to the code that defines the constants  which can be enumerations or  defines or anything else that devolves to an integer - in my case I had symbols defined in terms of other symbols  It also works well with sparse values  It even allows multiple names for the same value  returning the first one always  The only downside is that it requires you to make a table of the constants  which might become out-of-date as new ones are added for example   struct IdAndName      int          id     const char   name     bool operator lt  const IdAndName  amp rhs  const   return id  lt  rhs id        define ID AND NAME x    x   x    const char   IdToName int id  IdAndName  table begin  IdAndName  table end       if   table end - table begin   gt  1  amp  amp  table begin 0  id  gt  table begin 1  id        std  stable sort table begin  table end       IdAndName searchee     id  NULL       IdAndName  p   std  lower bound table begin  table end  searchee      return  p    table end    p- gt id    id    NULL   p- gt name     template lt int N gt  const char   IdToName int id  IdAndName   amp table  N        return IdToName id   amp table 0    amp table N        An example of how you d use it   static IdAndName WindowsErrorTable          ID AND NAME INT MAX                    flag value to indicate unsorted table    ID AND NAME NO ERROR      ID AND NAME ERROR INVALID FUNCTION      ID AND NAME ERROR FILE NOT FOUND      ID AND NAME ERROR PATH NOT FOUND      ID AND NAME ERROR TOO MANY OPEN FILES      ID AND NAME ERROR ACCESS DENIED      ID AND NAME ERROR INVALID HANDLE      ID AND NAME ERROR ARENA TRASHED      ID AND NAME ERROR NOT ENOUGH MEMORY      ID AND NAME ERROR INVALID BLOCK      ID AND NAME ERROR BAD ENVIRONMENT      ID AND NAME ERROR BAD FORMAT      ID AND NAME ERROR INVALID ACCESS      ID AND NAME ERROR INVALID DATA      ID AND NAME ERROR INVALID DRIVE      ID AND NAME ERROR CURRENT DIRECTORY      ID AND NAME ERROR NOT SAME DEVICE      ID AND NAME ERROR NO MORE FILES      const char   error name   IdToName GetLastError    WindowsErrorTable     The IdToName function relies on std  lower bound to do quick lookups  which requires the table to be sorted  If the first two entries in the table are out of order  the function will sort it automatically   Edit  A comment made me think of another way of using the same principle  A macro simplifies the generation of a big switch statement    define ID AND NAME x  case x  return  x  const char   WindowsErrorToName int id        switch id                ID AND NAME ERROR INVALID FUNCTION           ID AND NAME ERROR FILE NOT FOUND           ID AND NAME ERROR PATH NOT FOUND           ID AND NAME ERROR TOO MANY OPEN FILES           ID AND NAME ERROR ACCESS DENIED           ID AND NAME ERROR INVALID HANDLE           ID AND NAME ERROR ARENA TRASHED           ID AND NAME ERROR NOT ENOUGH MEMORY           ID AND NAME ERROR INVALID BLOCK           ID AND NAME ERROR BAD ENVIRONMENT           ID AND NAME ERROR BAD FORMAT           ID AND NAME ERROR INVALID ACCESS           ID AND NAME ERROR INVALID DATA           ID AND NAME ERROR INVALID DRIVE           ID AND NAME ERROR CURRENT DIRECTORY           ID AND NAME ERROR NOT SAME DEVICE           ID AND NAME ERROR NO MORE FILES           default  return NULL

User · Answer

It s unreleased software but it seems BOOST ENUM from Frank Laub could fit the bill  The part I like about it is that you can define an enum within the scope of a class which most of the Macro based enums usually don t let you do  It is located in the Boost Vault at  http   www boostpro com vault index php action downloadfile amp filename enum rev4 6 zip amp directory  amp  It hasn t seen any development since 2006 so I don t know how well it compiles with the new Boost releases  Look under libs test for an example of usage

User · Answer

I do this with separate side-by-side enum wrapper classes which are generated with macros  There are several advantages    Can generate them for enums I don t define  eg  OS platform header enums  Can incorporate range checking into the wrapper class Can do  smarter  formatting with bit field enums   The downside  of course  is that I need to duplicate the enum values in the formatter classes  and I don t have any script to generate them  Other than that  though  it seems to work pretty well   Here s an example of an enum from my codebase  sans all the framework code which implements the macros and templates  but you can get the idea   enum EHelpLocation       HELP LOCATION UNKNOWN     0       HELP LOCAL FILE           1       HELP HTML ONLINE          2      class CEnumFormatter EHelpLocation   public CEnumDefaultFormatter lt  EHelpLocation  gt    public      static inline CString FormatEnum  EHelpLocation eValue                 switch   eValue                         ON CASE VALUE RETURN STRING OF VALUE  HELP LOCATION UNKNOWN                ON CASE VALUE RETURN STRING OF VALUE  HELP LOCAL FILE                ON CASE VALUE RETURN STRING OF VALUE  HELP HTML ONLINE            default              return FormatAsNumber  eValue                       DECLARE RANGE CHECK CLASS  EHelpLocation  CRangeInfoSequential lt  HELP HTML ONLINE  gt     typedef ESmartEnum lt  EHelpLocation  HELP LOCATION UNKNOWN  CEnumFormatter EHelpLocation  CRangeInfo EHelpLocation  gt  SEHelpLocation    The idea then is instead of using EHelpLocation  you use SEHelpLocation  everything works the same  but you get range checking and a  Format    method on the enum variable itself  If you need to format a stand-alone value  you can use CEnumFormatter EHelpLocation  FormatEnum        Hope this is helpful  I realize this also doesn t address the original question about a script to actually generate the other class  but I hope the structure helps someone trying to solve the same problem  or write such a script

User · Answer

You may want to check out GCCXML   Running GCCXML on your sample code produces    lt GCC XML gt     lt Namespace id   1  name      members   3   mangled   Z2     gt     lt Namespace id   2  name  std  context   1  members    mangled   Z3std   gt     lt Enumeration id   3  name  MyEnum  context   1  location  f0 1  file  f0  line  1  gt       lt EnumValue name  FOO  init  0   gt       lt EnumValue name  BAR  init  80   gt     lt  Enumeration gt     lt File id  f0  name  my enum h   gt   lt  GCC XML gt    You could use any language you prefer to pull out the Enumeration and EnumValue tags and generate your desired code

User · Answer

Note that your conversion function should ideally be returning a const char     If you can afford to put your enums in their separate header files  you could perhaps do something like this with macros  oh  this will be ugly     include  enum def h   include  colour h   include  enum conv h   include  colour h    Where enum def h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  enum NAME    define ENUM ADD NAME  VALUE  NAME   VALUE   define ENUM END      And enum conv h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  const char    NAME   to string NAME val    switch  val     define ENUM ADD NAME  VALUE  case NAME  return  NAME   define ENUM END default  return  Invalid value         And finally  colour h has   ENUM START colour  ENUM ADD red    0xff0000  ENUM ADD green  0x00ff00  ENUM ADD blue   0x0000ff  ENUM END   And you can use the conversion function as   printf   s   colour to string colour  red      This is ugly  but it s the only way  at the preprocessor level  that lets you define your enum just in a single place in your code  Your code is therefore not prone to errors due to modifications to the enum  Your enum definition and the conversion function will always be in sync  However  I repeat  this is ugly

User · Answer

A problem with answer 0 is that the enum binary values do not necessarily start at 0 and are not necessarily contiguous   When I need this  I usually    pull the enum definition into my source edit it to get just the names do a macro to change the name to the case clause in the question  though typically on one line  case foo  return  foo   add the switch  default and other syntax to make it legal

User · Answer

hydroo  Without the extra file    define SOME ENUM DO        DO Foo        DO Bar        DO Baz    define MAKE ENUM VAR  VAR  enum MetaSyntacticVariable      SOME ENUM MAKE ENUM       define MAKE STRINGS VAR   VAR  const char  const MetaSyntacticVariableNames           SOME ENUM MAKE STRINGS

User · Answer

include  lt iostream gt   include  lt map gt   define IDMAP x   x  x   std  map lt int   std  string gt  enToStr  class mapEnumtoString   public      mapEnumtoString           mapEnumtoString amp  operator   int i std  string str                enToStr i    str          return  this        public     std  string operator     int i                return enToStr i             mapEnumtoString k  mapEnumtoString amp  init         return k     int main      init       IDMAP 1      IDMAP 2      IDMAP 3      IDMAP 4      IDMAP 5   std  cout lt  lt enToStr 1   std  cout lt  lt enToStr 2   std  cout lt  lt enToStr 3   std  cout lt  lt enToStr 4   std  cout lt  lt enToStr 5

User · Answer

X-macros are the best solution  Example    include  lt iostream gt   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     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c      int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl      colours def   X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta    However  I usually prefer the following method  so that it s possible to tweak the string a bit    define X a  b  a   define X a  b  b   X Red   red   X Green   green      etc

User · Answer

What I tend to do is create a C array with the names in the same order and position as the enum values   eg   enum colours   red  green  blue    const char  colour names        red    green    blue       then you can use the array in places where you want a human-readable value  eg  colours mycolour   red  cout  lt  lt   the colour is   lt  lt  colour names mycolour     You could experiment a little with the stringizing operator  see   in your preprocessor reference  that will do what you want  in some circumstances- eg    define printword XX  cout  lt  lt   XX  printword red     will print  red  to stdout  Unfortunately it won t work for a variable  as you ll get the variable name printed out

User · Answer

QT is able to pull that of  thanks to the meta object compiler   QNetworkReply  NetworkError error   error   fetchStuff     if  error    QNetworkReply  NoError         QString errorValue       QMetaObject meta   QNetworkReply  staticMetaObject       for  int i 0  i  lt  meta enumeratorCount      i             QMetaEnum m   meta enumerator i            if  m name      QLatin1String  quot NetworkError quot                   errorValue   QLatin1String m valueToKey error                 break                         QMessageBox box QMessageBox  Information   quot Failed to fetch quot                     quot Fetching stuff failed with error   1  quot   arg errorValue                    QMessageBox  Ok        box exec         return 1       In Qt every class that has the Q OBJECT macro will automatically have a static member  quot staticMetaObject quot  of the type QMetaObject  You can then find all sorts of cool things like the properties  signals  slots and indeed enums   Source

User · Answer

What I tend to do is create a C array with the names in the same order and position as the enum values   eg   enum colours   red  green  blue    const char  colour names        red    green    blue       then you can use the array in places where you want a human-readable value  eg  colours mycolour   red  cout  lt  lt   the colour is   lt  lt  colour names mycolour     You could experiment a little with the stringizing operator  see   in your preprocessor reference  that will do what you want  in some circumstances- eg    define printword XX  cout  lt  lt   XX  printword red     will print  red  to stdout  Unfortunately it won t work for a variable  as you ll get the variable name printed out

User · Answer

This can be done in C  11   include  lt map gt  enum MyEnum   AA  BB  CC  DD     static std  map lt  MyEnum  const char    gt  info         AA   This is an apple        BB   This is a book        CC   This is a coffee        DD   This is a door       void main         std  cout  lt  lt  info AA   lt  lt  endl                lt  lt  info BB   lt  lt  endl                lt  lt  info CC   lt  lt  endl                lt  lt  info DD   lt  lt  endl

User · Answer

It s unreleased software but it seems BOOST ENUM from Frank Laub could fit the bill  The part I like about it is that you can define an enum within the scope of a class which most of the Macro based enums usually don t let you do  It is located in the Boost Vault at  http   www boostpro com vault index php action downloadfile amp filename enum rev4 6 zip amp directory  amp  It hasn t seen any development since 2006 so I don t know how well it compiles with the new Boost releases  Look under libs test for an example of usage

User · Answer

include  lt stdarg h gt   include  lt algorithm gt   include  lt string gt    include  lt vector gt   include  lt sstream gt   include  lt map gt    define SMART ENUM EnumName                                           class EnumName                                                                                                                              private                                                                   static std  map lt int  std  string gt  nameMap                         public                                                                    enum    VA ARGS                                                   private                                                                   static std  map lt int  std  string gt  initMap                                                                                                       using namespace std                                                                                                                         int val   0                                                           string buf 1  buf 2  str      VA ARGS                                 replace str begin    str end                                          stringstream stream str                                               vector lt string gt  strings                                                while  getline stream  buf 1                                              strings push back buf 1                                           map lt int  string gt  tmp                                                  for vector lt string gt   iterator it   strings begin                                                              it    strings end                                                       it                                                                                                     buf 1 clear    buf 2 clear                                            stringstream localStream  it                                          localStream gt  gt  buf 1  gt  gt  buf 2                                          if buf 2 size    gt  0                                                       val   atoi buf 2 c str                                            tmp val      buf 1                                                                                                                      return tmp                                                                                                                          public                                                                    static std  string toString int aInt                                                                                                            return nameMap aInt                                                                                                                                                                                       std  map lt int  std  string gt                                             EnumName  nameMap   EnumName  initMap      Usage   SMART ENUM MyEnum  ONE 1  TWO  THREE  TEN 10  ELEVEN  cout lt  lt MyEnum  toString MyEnum  TWO   cout lt  lt MyEnum  toString 10

User · Answer

I came across this question when I was looking for a solution to my own problem for printing the  words  of the enumeration in C     I came back to provide a simple solution which answers the presented question as worded   All that s required is to  mirror  the enum list with a vector   enum class genre   Fiction  NonFiction  Periodical  Biography  Children     vector lt string gt genre tbl    Fiction    NonFiction    Periodical    Biography    Children       Because the enum as typed above will do the following by default   Fiction   0 NonFiction   1 Periodical   2 Biography   3 Children   4   This matches the vector positions which makes enum to string conversion pretty straight forward   string s1   genre tbl int genre  fiction      For my problem I created a user defined class called Book with a member called Gen of type genre   The program needed to be able to print the genre as the word   class book        ostream amp  operator lt  lt  ostream amp  os  genre g    return os  lt  lt  genre tbl int g       book b1  b1 Gen   genre 0  cout  lt  lt  b1 Gen    For which  Fiction  will print to screen in this case

User · Answer

This is a modification to  user3360260 answer  It has the following new features   MyEnum fromString const string amp   support compiles with VisualStudio 2012 the enum is an actual POD type  not just const declarations   so you can assign it to a variable  added C    range  feature  in form of vector  to allow  foreach  iteration over enum   Usage   SMART ENUM MyEnum  ONE 1  TWO  THREE  TEN 10  ELEVEN  MyEnum foo   MyEnum  TWO  cout  lt  lt  MyEnum  toString foo       static method cout  lt  lt  foo toString               member method cout  lt  lt  MyEnum  toString MyEnum  TWO   cout  lt  lt  MyEnum  toString 10   MyEnum foo   myEnum  fromString  TWO        C  11 iteration over all values for  auto x   MyEnum  allValues         cout  lt  lt  x toString    lt  lt  endl      Here s the code   define SMART ENUM EnumName                                           class EnumName                                                                                                                              public                                                                    EnumName     value 0                                                  EnumName int x    value x                                         public                                                                    enum    VA ARGS                                                   private                                                                   static void initMap std  map lt int  std  string gt  amp  tmp                                                                                                      using namespace std                                                                                                                         int val   0                                                           string buf 1  buf 2  str      VA ARGS                                 replace str begin    str end                                          stringstream stream str                                               vector lt string gt  strings                                                while  getline stream  buf 1                                              strings push back buf 1                                           for vector lt string gt   iterator it   strings begin                                                               it    strings end                                                        it                                                                                                     buf 1 clear    buf 2 clear                                            stringstream localStream  it                                          localStream gt  gt  buf 1  gt  gt  buf 2                                          if buf 2 size    gt  0                                                       val   atoi buf 2 c str                                            tmp val      buf 1                                                                                                                                                                                        int value                                                         public                                                                    operator int    const   return value                                  std  string toString void  const                                              return toString value                                                                                                               static std  string toString int aInt                                                                                                            return nameMap   aInt                                                                                                                   static EnumName fromString const std  string amp  s                                                                                                 auto it   find if nameMap   begin    nameMap   end     s  const std  pair lt int std  string gt  amp  p                  return p second    s                                                                                                                    if  it    nameMap   end                                                 value not found                                                         throw EnumName  Exception                                           else                                                                    return EnumName it- gt first                                                                                                                                                                                 class Exception   public std  exception                               static std  map lt int std  string gt  amp  nameMap                               static std  map lt int std  string gt  nameMap0                             if  nameMap0 size     0  initMap nameMap0                             return nameMap0                                                                                                                           static std  vector lt EnumName gt  allValues                                  std  vector lt EnumName gt  x    VA ARGS                                    return x                                                                                                                                  bool operator lt  const EnumName a  const   return  int  this  lt   int a                    Note that the conversion toString is a fast has lookup  while the conversion fromString is a slow linear search  But strings are so expensive anyways and the associated file IO   I didn t feel the need to optimize or use a bimap

User · Answer

include  lt stdarg h gt   include  lt algorithm gt   include  lt string gt    include  lt vector gt   include  lt sstream gt   include  lt map gt    define SMART ENUM EnumName                                           class EnumName                                                                                                                              private                                                                   static std  map lt int  std  string gt  nameMap                         public                                                                    enum    VA ARGS                                                   private                                                                   static std  map lt int  std  string gt  initMap                                                                                                       using namespace std                                                                                                                         int val   0                                                           string buf 1  buf 2  str      VA ARGS                                 replace str begin    str end                                          stringstream stream str                                               vector lt string gt  strings                                                while  getline stream  buf 1                                              strings push back buf 1                                           map lt int  string gt  tmp                                                  for vector lt string gt   iterator it   strings begin                                                              it    strings end                                                       it                                                                                                     buf 1 clear    buf 2 clear                                            stringstream localStream  it                                          localStream gt  gt  buf 1  gt  gt  buf 2                                          if buf 2 size    gt  0                                                       val   atoi buf 2 c str                                            tmp val      buf 1                                                                                                                      return tmp                                                                                                                          public                                                                    static std  string toString int aInt                                                                                                            return nameMap aInt                                                                                                                                                                                       std  map lt int  std  string gt                                             EnumName  nameMap   EnumName  initMap      Usage   SMART ENUM MyEnum  ONE 1  TWO  THREE  TEN 10  ELEVEN  cout lt  lt MyEnum  toString MyEnum  TWO   cout lt  lt MyEnum  toString 10

User · Answer

I do this with separate side-by-side enum wrapper classes which are generated with macros  There are several advantages    Can generate them for enums I don t define  eg  OS platform header enums  Can incorporate range checking into the wrapper class Can do  smarter  formatting with bit field enums   The downside  of course  is that I need to duplicate the enum values in the formatter classes  and I don t have any script to generate them  Other than that  though  it seems to work pretty well   Here s an example of an enum from my codebase  sans all the framework code which implements the macros and templates  but you can get the idea   enum EHelpLocation       HELP LOCATION UNKNOWN     0       HELP LOCAL FILE           1       HELP HTML ONLINE          2      class CEnumFormatter EHelpLocation   public CEnumDefaultFormatter lt  EHelpLocation  gt    public      static inline CString FormatEnum  EHelpLocation eValue                 switch   eValue                         ON CASE VALUE RETURN STRING OF VALUE  HELP LOCATION UNKNOWN                ON CASE VALUE RETURN STRING OF VALUE  HELP LOCAL FILE                ON CASE VALUE RETURN STRING OF VALUE  HELP HTML ONLINE            default              return FormatAsNumber  eValue                       DECLARE RANGE CHECK CLASS  EHelpLocation  CRangeInfoSequential lt  HELP HTML ONLINE  gt     typedef ESmartEnum lt  EHelpLocation  HELP LOCATION UNKNOWN  CEnumFormatter EHelpLocation  CRangeInfo EHelpLocation  gt  SEHelpLocation    The idea then is instead of using EHelpLocation  you use SEHelpLocation  everything works the same  but you get range checking and a  Format    method on the enum variable itself  If you need to format a stand-alone value  you can use CEnumFormatter EHelpLocation  FormatEnum        Hope this is helpful  I realize this also doesn t address the original question about a script to actually generate the other class  but I hope the structure helps someone trying to solve the same problem  or write such a script

User · Answer

Well  yet another option  A typical use case is where you need constant for the HTTP verbs as well as using is string version values   The example   int main         VERB a   VERB  GET    VERB b   VERB  GET    VERB c   VERB  POST    VERB d   VERB  PUT    VERB e   VERB  DELETE      std  cout  lt  lt  a toString    lt  lt  std  endl     std  cout  lt  lt  a  lt  lt  std  endl     if   a    VERB  GET         std  cout  lt  lt   yes   lt  lt  std  endl         if   a    b         std  cout  lt  lt   yes   lt  lt  std  endl         if   a    c         std  cout  lt  lt   no   lt  lt  std  endl           The VERB class      -----------------------------------------------------------    ----------------------------------------------------------- class VERB    private        private constants   enum Verb  GET  0  POST   PUT   DELETE          private string values   static const std  string theStrings          private value   const Verb value    const std  string text        private constructor   VERB  Verb v      value v   text  theStrings v              std  cout  lt  lt    constructor  n        public     operator const char       const   return text c str         operator const std  string     const   return text       const std  string toString    const   return text       bool operator     const VERB  amp  other  const   return   this  value    other value       bool operator     const VERB  amp  other  const   return       this     other           ---    static const VERB GET    static const VERB POST    static const VERB PUT    static const VERB DELETE       const std  string VERB  theStrings       GET    POST    PUT    DELETE     const VERB VERB  GET   VERB   VERB  Verb  GET     const VERB VERB  POST   VERB   VERB  Verb  POST     const VERB VERB  PUT   VERB   VERB  Verb  PUT     const VERB VERB  DELETE   VERB   VERB  Verb  DELETE        end of file

User · Answer

Using compound ternary statements can be somewhat elegant for enums with few elements  one-liner   The expression only grows approximately linearly in length with the number of elements too   Here s a good use case   enum log level  INFO  WARNING  ERROR       void logger  write const std  string log  const log level l                std  string s    l    INFO     INFO                          l    WARNING     WARNING                          l    ERROR     ERROR     UNKNOWN                   Of course  it s just another switch if statement block  but it s a single line statement  And as a matter of terseness vs  simplicity  it meets somewhere in the middle  As a constant expression  it can be easily made into an inline function as well

User · Answer

QT is able to pull that of  thanks to the meta object compiler   QNetworkReply  NetworkError error   error   fetchStuff     if  error    QNetworkReply  NoError         QString errorValue       QMetaObject meta   QNetworkReply  staticMetaObject       for  int i 0  i  lt  meta enumeratorCount      i             QMetaEnum m   meta enumerator i            if  m name      QLatin1String  quot NetworkError quot                   errorValue   QLatin1String m valueToKey error                 break                         QMessageBox box QMessageBox  Information   quot Failed to fetch quot                     quot Fetching stuff failed with error   1  quot   arg errorValue                    QMessageBox  Ok        box exec         return 1       In Qt every class that has the Q OBJECT macro will automatically have a static member  quot staticMetaObject quot  of the type QMetaObject  You can then find all sorts of cool things like the properties  signals  slots and indeed enums   Source

User · Answer

As variant  use simple lib   http   codeproject com Articles 42035 Enum-to-String-and-Vice-Versa-in-C  In the code   include  lt EnumString h gt   enum FORM       F NONE   0      F BOX      F CUBE      F SPHERE       add lines  Begin Enum String  FORM         Enum String  F NONE        Enum String  F BOX        Enum String  F CUBE        Enum String  F SPHERE      End Enum String    Work fine  if values in enum are not dublicate   Example usage  enum FORM f       const std  string amp  str   EnumString lt  FORM  gt   From  f      and vice versa  assert  EnumString lt  FORM  gt   To  f  str

User · Answer

That s pretty much the only way it can be done  an array of string could work also    The problem is  once a C program is compiled  the binary value of the enum is all that is used  and the name is gone

User · Answer

A problem with answer 0 is that the enum binary values do not necessarily start at 0 and are not necessarily contiguous   When I need this  I usually    pull the enum definition into my source edit it to get just the names do a macro to change the name to the case clause in the question  though typically on one line  case foo  return  foo   add the switch  default and other syntax to make it legal

User · Answer

This was my solution with BOOST    include  lt boost preprocessor hpp gt    define X STR ENUM TOSTRING CASE r  data  elem                                        case elem   return BOOST PP STRINGIZE elem     define X ENUM STR TOENUM IF r  data  elem                                            else if data    BOOST PP STRINGIZE elem   return elem    define STR ENUM name  enumerators                                                    enum name                                                                             BOOST PP SEQ ENUM enumerators                                                                                                                                                                                                                     inline const QString enumToStr name v                                                                                                                                   switch  v                                                                                                                                                               BOOST PP SEQ FOR EACH                                                                 X STR ENUM TOSTRING CASE                                                          name                                                                              enumerators                                                                                                                                                                                                                                       default                                                                               return   Unknown   BOOST PP STRINGIZE name                                                                                                                                                                                                                                                                                  template  lt typename T gt                                                              inline const T strToEnum QString v                                                                                                                                  template  lt  gt                                                                        inline const name strToEnum QString v                                                                                                                                   if v                                                                                  throw std  runtime error  Empty enum value                                                                                                                      BOOST PP SEQ FOR EACH                                                                 X ENUM STR TOENUM IF                                                              v                                                                                 enumerators                                                                                                                                                                                                                                       else                                                                                  throw std  runtime error                                                                      QString   Unknown value  1 for enum  2                                                 arg v                                                                             arg BOOST PP STRINGIZE name                                                           toStdString   c str                                      To create enum  declare   STR ENUM       SERVICE RELOAD           reload log           reload settings           reload qxml server      For conversions   SERVICE RELOAD serviceReloadEnum   strToEnum lt SERVICE RELOAD gt   reload log    QString serviceReloadStr   enumToStr reload log

User · Answer

This was my solution with BOOST    include  lt boost preprocessor hpp gt    define X STR ENUM TOSTRING CASE r  data  elem                                        case elem   return BOOST PP STRINGIZE elem     define X ENUM STR TOENUM IF r  data  elem                                            else if data    BOOST PP STRINGIZE elem   return elem    define STR ENUM name  enumerators                                                    enum name                                                                             BOOST PP SEQ ENUM enumerators                                                                                                                                                                                                                     inline const QString enumToStr name v                                                                                                                                   switch  v                                                                                                                                                               BOOST PP SEQ FOR EACH                                                                 X STR ENUM TOSTRING CASE                                                          name                                                                              enumerators                                                                                                                                                                                                                                       default                                                                               return   Unknown   BOOST PP STRINGIZE name                                                                                                                                                                                                                                                                                  template  lt typename T gt                                                              inline const T strToEnum QString v                                                                                                                                  template  lt  gt                                                                        inline const name strToEnum QString v                                                                                                                                   if v                                                                                  throw std  runtime error  Empty enum value                                                                                                                      BOOST PP SEQ FOR EACH                                                                 X ENUM STR TOENUM IF                                                              v                                                                                 enumerators                                                                                                                                                                                                                                       else                                                                                  throw std  runtime error                                                                      QString   Unknown value  1 for enum  2                                                 arg v                                                                             arg BOOST PP STRINGIZE name                                                           toStdString   c str                                      To create enum  declare   STR ENUM       SERVICE RELOAD           reload log           reload settings           reload qxml server      For conversions   SERVICE RELOAD serviceReloadEnum   strToEnum lt SERVICE RELOAD gt   reload log    QString serviceReloadStr   enumToStr reload log

User · Answer

Not so long ago I made some trick to have enums properly displayed in QComboBox and to have definition of enum and string representations as one statement   pragma once  include  lt boost unordered map hpp gt   namespace enumeration       struct enumerator base   boost  noncopyable            typedef          boost  unordered map lt int  std  wstring gt           kv storage t        typedef          kv storage t  value type          kv type        kv storage t const  amp  kv   const                  return storage                  LPCWSTR name int i  const                  kv storage t  const iterator it   storage  find i            if it    storage  end                return it- gt second c str             return L empty               protected        kv storage t storage             template lt class T gt     struct enumerator      template lt class D gt     struct enum singleton   enumerator base            static enumerator base const  amp  instance                    static D inst           return inst                    define QENUM ENTRY K  V  N   K  N storage  insert std  make pair  int K  V      define QBEGIN ENUM NAME  C      enum NAME                                                          C                                                                                                                              define QEND ENUM NAME                             namespace enumeration                             template lt  gt                struct enumerator lt NAME gt        enum singleton lt  enumerator lt NAME gt   gt                               enumerator                    usage    QBEGIN ENUM test t     QENUM ENTRY test entry 1  L number uno      QENUM ENTRY test entry 2  L number dos      QENUM ENTRY test entry 3  L number tres   QEND ENUM test t           Now you ve got enumeration  enum singleton lt your enum gt   instance   able to convert enums to strings  If you replace kv storage t with boost  bimap  you will also be able to do backward conversion  Common base class for converter was introduced to store it in Qt object  because Qt objects couldn t be templates  Previous appearance

User · Answer

This can be done in C  11   include  lt map gt  enum MyEnum   AA  BB  CC  DD     static std  map lt  MyEnum  const char    gt  info         AA   This is an apple        BB   This is a book        CC   This is a coffee        DD   This is a door       void main         std  cout  lt  lt  info AA   lt  lt  endl                lt  lt  info BB   lt  lt  endl                lt  lt  info CC   lt  lt  endl                lt  lt  info DD   lt  lt  endl

User · Answer

X-macros are the best solution  Example    include  lt iostream gt   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     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c      int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl      colours def   X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta    However  I usually prefer the following method  so that it s possible to tweak the string a bit    define X a  b  a   define X a  b  b   X Red   red   X Green   green      etc

User · Answer

Here a one-file solution  based on elegant answer by  Marcin    include  lt iostream gt    define ENUM TXT   X Red    X Green    X Blue    X Cyan    X Yellow    X Magenta     enum Colours       define X a  a  ENUM TXT     undef X     ColoursCount     char const  const colours str           define X a   a  ENUM TXT     undef X     0     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c   lt  lt  std  endl     int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl

User · Answer

hydroo  Without the extra file    define SOME ENUM DO        DO Foo        DO Bar        DO Baz    define MAKE ENUM VAR  VAR  enum MetaSyntacticVariable      SOME ENUM MAKE ENUM       define MAKE STRINGS VAR   VAR  const char  const MetaSyntacticVariableNames           SOME ENUM MAKE STRINGS

User · Answer

What I tend to do is create a C array with the names in the same order and position as the enum values   eg   enum colours   red  green  blue    const char  colour names        red    green    blue       then you can use the array in places where you want a human-readable value  eg  colours mycolour   red  cout  lt  lt   the colour is   lt  lt  colour names mycolour     You could experiment a little with the stringizing operator  see   in your preprocessor reference  that will do what you want  in some circumstances- eg    define printword XX  cout  lt  lt   XX  printword red     will print  red  to stdout  Unfortunately it won t work for a variable  as you ll get the variable name printed out

User · Answer

Here a one-file solution  based on elegant answer by  Marcin    include  lt iostream gt    define ENUM TXT   X Red    X Green    X Blue    X Cyan    X Yellow    X Magenta     enum Colours       define X a  a  ENUM TXT     undef X     ColoursCount     char const  const colours str           define X a   a  ENUM TXT     undef X     0     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c   lt  lt  std  endl     int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl

User · Answer

I have an incredibly simple to use macro that does this in a completely DRY fashion  It involves variadic macros and some simple parsing magic  Here goes    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 this in your code  simply do   AWESOME MAKE ENUM Animal      DOG      CAT      HORSE

User · Answer

That s pretty much the only way it can be done  an array of string could work also    The problem is  once a C program is compiled  the binary value of the enum is all that is used  and the name is gone

User · Answer

Note that your conversion function should ideally be returning a const char     If you can afford to put your enums in their separate header files  you could perhaps do something like this with macros  oh  this will be ugly     include  enum def h   include  colour h   include  enum conv h   include  colour h    Where enum def h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  enum NAME    define ENUM ADD NAME  VALUE  NAME   VALUE   define ENUM END      And enum conv h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  const char    NAME   to string NAME val    switch  val     define ENUM ADD NAME  VALUE  case NAME  return  NAME   define ENUM END default  return  Invalid value         And finally  colour h has   ENUM START colour  ENUM ADD red    0xff0000  ENUM ADD green  0x00ff00  ENUM ADD blue   0x0000ff  ENUM END   And you can use the conversion function as   printf   s   colour to string colour  red      This is ugly  but it s the only way  at the preprocessor level  that lets you define your enum just in a single place in your code  Your code is therefore not prone to errors due to modifications to the enum  Your enum definition and the conversion function will always be in sync  However  I repeat  this is ugly

User · Answer

This is a modification to  user3360260 answer  It has the following new features   MyEnum fromString const string amp   support compiles with VisualStudio 2012 the enum is an actual POD type  not just const declarations   so you can assign it to a variable  added C    range  feature  in form of vector  to allow  foreach  iteration over enum   Usage   SMART ENUM MyEnum  ONE 1  TWO  THREE  TEN 10  ELEVEN  MyEnum foo   MyEnum  TWO  cout  lt  lt  MyEnum  toString foo       static method cout  lt  lt  foo toString               member method cout  lt  lt  MyEnum  toString MyEnum  TWO   cout  lt  lt  MyEnum  toString 10   MyEnum foo   myEnum  fromString  TWO        C  11 iteration over all values for  auto x   MyEnum  allValues         cout  lt  lt  x toString    lt  lt  endl      Here s the code   define SMART ENUM EnumName                                           class EnumName                                                                                                                              public                                                                    EnumName     value 0                                                  EnumName int x    value x                                         public                                                                    enum    VA ARGS                                                   private                                                                   static void initMap std  map lt int  std  string gt  amp  tmp                                                                                                      using namespace std                                                                                                                         int val   0                                                           string buf 1  buf 2  str      VA ARGS                                 replace str begin    str end                                          stringstream stream str                                               vector lt string gt  strings                                                while  getline stream  buf 1                                              strings push back buf 1                                           for vector lt string gt   iterator it   strings begin                                                               it    strings end                                                        it                                                                                                     buf 1 clear    buf 2 clear                                            stringstream localStream  it                                          localStream gt  gt  buf 1  gt  gt  buf 2                                          if buf 2 size    gt  0                                                       val   atoi buf 2 c str                                            tmp val      buf 1                                                                                                                                                                                        int value                                                         public                                                                    operator int    const   return value                                  std  string toString void  const                                              return toString value                                                                                                               static std  string toString int aInt                                                                                                            return nameMap   aInt                                                                                                                   static EnumName fromString const std  string amp  s                                                                                                 auto it   find if nameMap   begin    nameMap   end     s  const std  pair lt int std  string gt  amp  p                  return p second    s                                                                                                                    if  it    nameMap   end                                                 value not found                                                         throw EnumName  Exception                                           else                                                                    return EnumName it- gt first                                                                                                                                                                                 class Exception   public std  exception                               static std  map lt int std  string gt  amp  nameMap                               static std  map lt int std  string gt  nameMap0                             if  nameMap0 size     0  initMap nameMap0                             return nameMap0                                                                                                                           static std  vector lt EnumName gt  allValues                                  std  vector lt EnumName gt  x    VA ARGS                                    return x                                                                                                                                  bool operator lt  const EnumName a  const   return  int  this  lt   int a                    Note that the conversion toString is a fast has lookup  while the conversion fromString is a slow linear search  But strings are so expensive anyways and the associated file IO   I didn t feel the need to optimize or use a bimap

User · Answer

Well  yet another option  A typical use case is where you need constant for the HTTP verbs as well as using is string version values   The example   int main         VERB a   VERB  GET    VERB b   VERB  GET    VERB c   VERB  POST    VERB d   VERB  PUT    VERB e   VERB  DELETE      std  cout  lt  lt  a toString    lt  lt  std  endl     std  cout  lt  lt  a  lt  lt  std  endl     if   a    VERB  GET         std  cout  lt  lt   yes   lt  lt  std  endl         if   a    b         std  cout  lt  lt   yes   lt  lt  std  endl         if   a    c         std  cout  lt  lt   no   lt  lt  std  endl           The VERB class      -----------------------------------------------------------    ----------------------------------------------------------- class VERB    private        private constants   enum Verb  GET  0  POST   PUT   DELETE          private string values   static const std  string theStrings          private value   const Verb value    const std  string text        private constructor   VERB  Verb v      value v   text  theStrings v              std  cout  lt  lt    constructor  n        public     operator const char       const   return text c str         operator const std  string     const   return text       const std  string toString    const   return text       bool operator     const VERB  amp  other  const   return   this  value    other value       bool operator     const VERB  amp  other  const   return       this     other           ---    static const VERB GET    static const VERB POST    static const VERB PUT    static const VERB DELETE       const std  string VERB  theStrings       GET    POST    PUT    DELETE     const VERB VERB  GET   VERB   VERB  Verb  GET     const VERB VERB  POST   VERB   VERB  Verb  POST     const VERB VERB  PUT   VERB   VERB  Verb  PUT     const VERB VERB  DELETE   VERB   VERB  Verb  DELETE        end of file

User · Answer

A problem with answer 0 is that the enum binary values do not necessarily start at 0 and are not necessarily contiguous   When I need this  I usually    pull the enum definition into my source edit it to get just the names do a macro to change the name to the case clause in the question  though typically on one line  case foo  return  foo   add the switch  default and other syntax to make it legal

User · Answer

A problem with answer 0 is that the enum binary values do not necessarily start at 0 and are not necessarily contiguous   When I need this  I usually    pull the enum definition into my source edit it to get just the names do a macro to change the name to the case clause in the question  though typically on one line  case foo  return  foo   add the switch  default and other syntax to make it legal

User · Answer

X-macros are the best solution  Example    include  lt iostream gt   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     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c      int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl      colours def   X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta    However  I usually prefer the following method  so that it s possible to tweak the string a bit    define X a  b  a   define X a  b  b   X Red   red   X Green   green      etc

User · Answer

QT is able to pull that of  thanks to the meta object compiler   QNetworkReply  NetworkError error   error   fetchStuff     if  error    QNetworkReply  NoError         QString errorValue       QMetaObject meta   QNetworkReply  staticMetaObject       for  int i 0  i  lt  meta enumeratorCount      i             QMetaEnum m   meta enumerator i            if  m name      QLatin1String  quot NetworkError quot                   errorValue   QLatin1String m valueToKey error                 break                         QMessageBox box QMessageBox  Information   quot Failed to fetch quot                     quot Fetching stuff failed with error   1  quot   arg errorValue                    QMessageBox  Ok        box exec         return 1       In Qt every class that has the Q OBJECT macro will automatically have a static member  quot staticMetaObject quot  of the type QMetaObject  You can then find all sorts of cool things like the properties  signals  slots and indeed enums   Source

User · Answer

define stringify  name     name  enum MyEnum       ENUMVAL1       stuff     stringify EnumName  ENUMVAL1       Returns MyEnum  ENUMVAL1   Further discussion on this method   Preprocessor directive tricks for newcomers

User · Answer

As variant  use simple lib   http   codeproject com Articles 42035 Enum-to-String-and-Vice-Versa-in-C  In the code   include  lt EnumString h gt   enum FORM       F NONE   0      F BOX      F CUBE      F SPHERE       add lines  Begin Enum String  FORM         Enum String  F NONE        Enum String  F BOX        Enum String  F CUBE        Enum String  F SPHERE      End Enum String    Work fine  if values in enum are not dublicate   Example usage  enum FORM f       const std  string amp  str   EnumString lt  FORM  gt   From  f      and vice versa  assert  EnumString lt  FORM  gt   To  f  str

User · Answer

You may want to check out GCCXML   Running GCCXML on your sample code produces    lt GCC XML gt     lt Namespace id   1  name      members   3   mangled   Z2     gt     lt Namespace id   2  name  std  context   1  members    mangled   Z3std   gt     lt Enumeration id   3  name  MyEnum  context   1  location  f0 1  file  f0  line  1  gt       lt EnumValue name  FOO  init  0   gt       lt EnumValue name  BAR  init  80   gt     lt  Enumeration gt     lt File id  f0  name  my enum h   gt   lt  GCC XML gt    You could use any language you prefer to pull out the Enumeration and EnumValue tags and generate your desired code

User · Answer

Suma s macro solution is nice  You don t need to have two different macro s  though  C   wil happily include a header twice  Just leave out the include guard   So you d have an foobar h defining just  ENUM Foo  1  ENUM Bar  2    and you would include it like this    define ENUMFACTORY ARGUMENT  foobar h   include  enumfactory h    enumfactory h will do 2  include ENUMFACTORY ARGUMENTs  In the first round  it expands ENUM like Suma s DECLARE ENUM  in the second round ENUM works like DEFINE ENUM   You can include enumfactory h multiple times  too  as long as you pass in different  define s for ENUMFACTORY ARGUMENT

User · Answer

Interesting to see the number of ways  here s one i used a long time ago    in file myenummap h    include  lt map gt   include  lt string gt  enum test  one  two  three  five 5  six  seven    struct mymap   std  map lt unsigned int  std  string gt      mymap           this- gt operator    one      ONE       this- gt operator    two      TWO       this- gt operator    three      THREE       this- gt operator    five      FIVE       this- gt operator    six      SIX       this- gt operator    seven      SEVEN           mymap           in main cpp   include  myenummap h       mymap nummap  std  cout lt  lt  nummap  one    lt  lt  std  endl    Its not const  but its convenient   Here s another way that uses C  11 features  This is const  doesn t inherit an STL container and is a little tidier    include  lt vector gt   include  lt string gt   include  lt algorithm gt   include  lt iostream gt     These stay together and must be modified together enum test  one  two  three  five 5  six  seven    std  string enum to str test const amp  e        typedef std  pair lt int std  string gt  mapping      auto m      test const amp  e std  string const amp  s  return mapping static cast lt int gt  e  s          std  vector lt mapping gt  const nummap                   m one  one             m two  two             m three  three            m five  five            m six  six            m seven  seven               for auto i    nummap                if i first  static cast lt int gt  e                         return i second                      return        int main         std  cout lt  lt  enum to str  46    lt  lt  std  endl    compilation will fail     std  cout lt  lt   Invalid enum to string       lt  lt  enum to str  test 46     lt  lt      lt  lt std  endl    returns an empty string     std  cout lt  lt   Enumval five to string      lt  lt  enum to str  five    lt  lt       lt  lt  std  endl    works     return 0

User · Answer

The following ruby script attempts to parse the headers and builts the required sources alongside the original headers.

#! /usr/bin/env ruby

# Let's "parse" the headers
# Note that using a regular expression is rather fragile
# and may break on some inputs

GLOBS = [
  "toto/*.h",
  "tutu/*.h",
  "tutu/*.hxx"
]

enums = {}
GLOBS.each { |glob|
  Dir[glob].each { |header|
    enums[header] = File.open(header, 'rb') { |f|
      f.read
    }.scan(/enum\s+(\w+)\s+\{\s*([^}]+?)\s*\}/m).collect { |enum_name, enum_key_and_values|
      [
        enum_name, enum_key_and_values.split(/\s*,\s*/).collect { |enum_key_and_value|
          enum_key_and_value.split(/\s*=\s*/).first
        }
      ]
    }
  }
}


# Now we build a .h and .cpp alongside the parsed headers
# using the template engine provided with ruby
require 'erb'

template_h = ERB.new <<-EOS
#ifndef <%= enum_name %>_to_string_h_
#define <%= enum_name %>_to_string_h_ 1

#include "<%= header %>"
char* enum_to_string(<%= enum_name %> e);

#endif
EOS

template_cpp = ERB.new <<-EOS
#include "<%= enum_name %>_to_string.h"

char* enum_to_string(<%= enum_name %> e)
{
  switch (e)
  {<% enum_keys.each do |enum_key| %>
    case <%= enum_key %>: return "<%= enum_key %>";<% end %>
    default: return "INVALID <%= enum_name %> VALUE";
  }
}
EOS

enums.each { |header, enum_name_and_keys|
  enum_name_and_keys.each { |enum_name, enum_keys|
    File.open("#{File.dirname(header)}/#{enum_name}_to_string.h", 'wb') { |built_h|
      built_h.write(template_h.result(binding))
    }

    File.open("#{File.dirname(header)}/#{enum_name}_to_string.cpp", 'wb') { |built_cpp|
      built_cpp.write(template_cpp.result(binding))
    }
  }
}

Using regular expressions makes this "parser" quite fragile, it may not be able to handle your specific headers gracefully.

Let's say you have a header toto/a.h, containing definitions for enums MyEnum and MyEnum2. The script will build:

toto/MyEnum_to_string.h
toto/MyEnum_to_string.cpp
toto/MyEnum2_to_string.h
toto/MyEnum2_to_string.cpp

More robust solutions would be:

Build all sources defining enums and their operations from another source. This means you'll define your enums in a XML/YML/whatever file which is much easier to parse than C/C++.
Use a real compiler such as suggested by Avdi.
Use preprocessor macros with or without templates.

User · Answer

Not so long ago I made some trick to have enums properly displayed in QComboBox and to have definition of enum and string representations as one statement   pragma once  include  lt boost unordered map hpp gt   namespace enumeration       struct enumerator base   boost  noncopyable            typedef          boost  unordered map lt int  std  wstring gt           kv storage t        typedef          kv storage t  value type          kv type        kv storage t const  amp  kv   const                  return storage                  LPCWSTR name int i  const                  kv storage t  const iterator it   storage  find i            if it    storage  end                return it- gt second c str             return L empty               protected        kv storage t storage             template lt class T gt     struct enumerator      template lt class D gt     struct enum singleton   enumerator base            static enumerator base const  amp  instance                    static D inst           return inst                    define QENUM ENTRY K  V  N   K  N storage  insert std  make pair  int K  V      define QBEGIN ENUM NAME  C      enum NAME                                                          C                                                                                                                              define QEND ENUM NAME                             namespace enumeration                             template lt  gt                struct enumerator lt NAME gt        enum singleton lt  enumerator lt NAME gt   gt                               enumerator                    usage    QBEGIN ENUM test t     QENUM ENTRY test entry 1  L number uno      QENUM ENTRY test entry 2  L number dos      QENUM ENTRY test entry 3  L number tres   QEND ENUM test t           Now you ve got enumeration  enum singleton lt your enum gt   instance   able to convert enums to strings  If you replace kv storage t with boost  bimap  you will also be able to do backward conversion  Common base class for converter was introduced to store it in Qt object  because Qt objects couldn t be templates  Previous appearance

User · Answer

You may want to check out GCCXML   Running GCCXML on your sample code produces    lt GCC XML gt     lt Namespace id   1  name      members   3   mangled   Z2     gt     lt Namespace id   2  name  std  context   1  members    mangled   Z3std   gt     lt Enumeration id   3  name  MyEnum  context   1  location  f0 1  file  f0  line  1  gt       lt EnumValue name  FOO  init  0   gt       lt EnumValue name  BAR  init  80   gt     lt  Enumeration gt     lt File id  f0  name  my enum h   gt   lt  GCC XML gt    You could use any language you prefer to pull out the Enumeration and EnumValue tags and generate your desired code

User · Answer

Interesting to see the number of ways  here s one i used a long time ago    in file myenummap h    include  lt map gt   include  lt string gt  enum test  one  two  three  five 5  six  seven    struct mymap   std  map lt unsigned int  std  string gt      mymap           this- gt operator    one      ONE       this- gt operator    two      TWO       this- gt operator    three      THREE       this- gt operator    five      FIVE       this- gt operator    six      SIX       this- gt operator    seven      SEVEN           mymap           in main cpp   include  myenummap h       mymap nummap  std  cout lt  lt  nummap  one    lt  lt  std  endl    Its not const  but its convenient   Here s another way that uses C  11 features  This is const  doesn t inherit an STL container and is a little tidier    include  lt vector gt   include  lt string gt   include  lt algorithm gt   include  lt iostream gt     These stay together and must be modified together enum test  one  two  three  five 5  six  seven    std  string enum to str test const amp  e        typedef std  pair lt int std  string gt  mapping      auto m      test const amp  e std  string const amp  s  return mapping static cast lt int gt  e  s          std  vector lt mapping gt  const nummap                   m one  one             m two  two             m three  three            m five  five            m six  six            m seven  seven               for auto i    nummap                if i first  static cast lt int gt  e                         return i second                      return        int main         std  cout lt  lt  enum to str  46    lt  lt  std  endl    compilation will fail     std  cout lt  lt   Invalid enum to string       lt  lt  enum to str  test 46     lt  lt      lt  lt std  endl    returns an empty string     std  cout lt  lt   Enumval five to string      lt  lt  enum to str  five    lt  lt       lt  lt  std  endl    works     return 0

User · Answer

Using compound ternary statements can be somewhat elegant for enums with few elements  one-liner   The expression only grows approximately linearly in length with the number of elements too   Here s a good use case   enum log level  INFO  WARNING  ERROR       void logger  write const std  string log  const log level l                std  string s    l    INFO     INFO                          l    WARNING     WARNING                          l    ERROR     ERROR     UNKNOWN                   Of course  it s just another switch if statement block  but it s a single line statement  And as a matter of terseness vs  simplicity  it meets somewhere in the middle  As a constant expression  it can be easily made into an inline function as well

User · Answer

hydroo  Without the extra file    define SOME ENUM DO        DO Foo        DO Bar        DO Baz    define MAKE ENUM VAR  VAR  enum MetaSyntacticVariable      SOME ENUM MAKE ENUM       define MAKE STRINGS VAR   VAR  const char  const MetaSyntacticVariableNames           SOME ENUM MAKE STRINGS

User · Answer

I want to post this in case someone finds it useful    In my case  I simply need to generate ToString   and FromString   functions for a single C  11 enum from a single  hpp file   I wrote a python script that parses the header file containing the enum items and generates the functions in a new  cpp file    You can add this script in CMakeLists txt with execute process  or as a pre-build event in Visual Studio  The  cpp file will be automatically generated  without the need to manually update it each time a new enum item is added   generate enum strings py    This script is used to generate strings from C   enums  import re import sys import os  fileName   sys argv 1  enumName   os path basename os path splitext fileName  0    with open fileName   r   as f      content   f read   replace   n        searchResult   re search  enum                 content  tokens   searchResult group 2  tokens   tokens split      tokens   map str strip  tokens  tokens   map lambda token  re search    a-zA-Z0-9       token  group 1   tokens   textOut      textOut      n include      enumName     hpp  n n  textOut     namespace myns n  textOut       n  textOut         std  string ToString ErrorCode errorCode  n  textOut           n  textOut             switch  errorCode  n  textOut               n   for token in tokens      textOut             case     enumName          token      n      textOut                 return      token       n   textOut             default  n  textOut                 return  Last   n  textOut               n  textOut           n  textOut      n  textOut             enumName     FromString const std  string  amp errorCode  n  textOut           n  textOut             if       tokens 0          errorCode  n  textOut               n  textOut                 return     enumName          tokens 0       n  textOut               n   for token in tokens 1        textOut             else if      token         errorCode  n      textOut               n      textOut                 return     enumName          token      n      textOut               n   textOut      n  textOut             return     enumName      Last  n  textOut           n  textOut       n   fileOut   open enumName     cpp    w   fileOut write textOut    Example   ErrorCode hpp   pragma once   include  lt string gt   include  lt cstdint gt   namespace myns       enum class ErrorCode   uint32 t               OK   0          OutOfSpace          ConnectionFailure          InvalidJson          DatabaseFailure          HttpError          FileSystemError          FailedToEncrypt          FailedToDecrypt          EndOfFile          FailedToOpenFileForRead          FailedToOpenFileForWrite          FailedToLaunchProcess           Last             std  string ToString ErrorCode errorCode       ErrorCode FromString const std  string  amp errorCode       Run python generate enum strings py ErrorCode hpp  Result   ErrorCode cpp   include  ErrorCode hpp   namespace myns       std  string ToString ErrorCode errorCode                switch  errorCode                    case ErrorCode  OK              return  OK           case ErrorCode  OutOfSpace              return  OutOfSpace           case ErrorCode  ConnectionFailure              return  ConnectionFailure           case ErrorCode  InvalidJson              return  InvalidJson           case ErrorCode  DatabaseFailure              return  DatabaseFailure           case ErrorCode  HttpError              return  HttpError           case ErrorCode  FileSystemError              return  FileSystemError           case ErrorCode  FailedToEncrypt              return  FailedToEncrypt           case ErrorCode  FailedToDecrypt              return  FailedToDecrypt           case ErrorCode  EndOfFile              return  EndOfFile           case ErrorCode  FailedToOpenFileForRead              return  FailedToOpenFileForRead           case ErrorCode  FailedToOpenFileForWrite              return  FailedToOpenFileForWrite           case ErrorCode  FailedToLaunchProcess              return  FailedToLaunchProcess           case ErrorCode  Last              return  Last           default              return  Last                        ErrorCode FromString const std  string  amp errorCode                if   OK     errorCode                        return ErrorCode  OK                    else if  OutOfSpace     errorCode                        return ErrorCode  OutOfSpace                    else if  ConnectionFailure     errorCode                        return ErrorCode  ConnectionFailure                    else if  InvalidJson     errorCode                        return ErrorCode  InvalidJson                    else if  DatabaseFailure     errorCode                        return ErrorCode  DatabaseFailure                    else if  HttpError     errorCode                        return ErrorCode  HttpError                    else if  FileSystemError     errorCode                        return ErrorCode  FileSystemError                    else if  FailedToEncrypt     errorCode                        return ErrorCode  FailedToEncrypt                    else if  FailedToDecrypt     errorCode                        return ErrorCode  FailedToDecrypt                    else if  EndOfFile     errorCode                        return ErrorCode  EndOfFile                    else if  FailedToOpenFileForRead     errorCode                        return ErrorCode  FailedToOpenFileForRead                    else if  FailedToOpenFileForWrite     errorCode                        return ErrorCode  FailedToOpenFileForWrite                    else if  FailedToLaunchProcess     errorCode                        return ErrorCode  FailedToLaunchProcess                    else if  Last     errorCode                        return ErrorCode  Last                     return ErrorCode  Last

User · Answer

Adding even more simplicity of use to Jasper Bekkers  fantastic answer   Set up once    define MAKE ENUM VAR  VAR   define MAKE STRINGS VAR   VAR   define MAKE ENUM AND STRINGS source  enumName  enumStringName        enum enumName         source MAKE ENUM            const char  const enumStringName             source MAKE STRINGS             Then  for usage    define SOME ENUM DO        DO Foo        DO Bar        DO Baz      MAKE ENUM AND STRINGS SOME ENUM  someEnum  someEnumNames

User · Answer

Another answer  in some contexts  it makes sense to define your enumeration in a non-code format  like a CSV  YAML  or XML file  and then generate both the C   enumeration code and the to-string code from the definition   This approach may or may not be practical in your application  but it s something to keep in mind

User · Answer

Suma s macro solution is nice  You don t need to have two different macro s  though  C   wil happily include a header twice  Just leave out the include guard   So you d have an foobar h defining just  ENUM Foo  1  ENUM Bar  2    and you would include it like this    define ENUMFACTORY ARGUMENT  foobar h   include  enumfactory h    enumfactory h will do 2  include ENUMFACTORY ARGUMENTs  In the first round  it expands ENUM like Suma s DECLARE ENUM  in the second round ENUM works like DEFINE ENUM   You can include enumfactory h multiple times  too  as long as you pass in different  define s for ENUMFACTORY ARGUMENT

User · Answer

QT is able to pull that of  thanks to the meta object compiler   QNetworkReply  NetworkError error   error   fetchStuff     if  error    QNetworkReply  NoError         QString errorValue       QMetaObject meta   QNetworkReply  staticMetaObject       for  int i 0  i  lt  meta enumeratorCount      i             QMetaEnum m   meta enumerator i            if  m name      QLatin1String  quot NetworkError quot                   errorValue   QLatin1String m valueToKey error                 break                         QMessageBox box QMessageBox  Information   quot Failed to fetch quot                     quot Fetching stuff failed with error   1  quot   arg errorValue                    QMessageBox  Ok        box exec         return 1       In Qt every class that has the Q OBJECT macro will automatically have a static member  quot staticMetaObject quot  of the type QMetaObject  You can then find all sorts of cool things like the properties  signals  slots and indeed enums   Source

User · Answer

The following ruby script attempts to parse the headers and builts the required sources alongside the original headers.

#! /usr/bin/env ruby

# Let's "parse" the headers
# Note that using a regular expression is rather fragile
# and may break on some inputs

GLOBS = [
  "toto/*.h",
  "tutu/*.h",
  "tutu/*.hxx"
]

enums = {}
GLOBS.each { |glob|
  Dir[glob].each { |header|
    enums[header] = File.open(header, 'rb') { |f|
      f.read
    }.scan(/enum\s+(\w+)\s+\{\s*([^}]+?)\s*\}/m).collect { |enum_name, enum_key_and_values|
      [
        enum_name, enum_key_and_values.split(/\s*,\s*/).collect { |enum_key_and_value|
          enum_key_and_value.split(/\s*=\s*/).first
        }
      ]
    }
  }
}


# Now we build a .h and .cpp alongside the parsed headers
# using the template engine provided with ruby
require 'erb'

template_h = ERB.new <<-EOS
#ifndef <%= enum_name %>_to_string_h_
#define <%= enum_name %>_to_string_h_ 1

#include "<%= header %>"
char* enum_to_string(<%= enum_name %> e);

#endif
EOS

template_cpp = ERB.new <<-EOS
#include "<%= enum_name %>_to_string.h"

char* enum_to_string(<%= enum_name %> e)
{
  switch (e)
  {<% enum_keys.each do |enum_key| %>
    case <%= enum_key %>: return "<%= enum_key %>";<% end %>
    default: return "INVALID <%= enum_name %> VALUE";
  }
}
EOS

enums.each { |header, enum_name_and_keys|
  enum_name_and_keys.each { |enum_name, enum_keys|
    File.open("#{File.dirname(header)}/#{enum_name}_to_string.h", 'wb') { |built_h|
      built_h.write(template_h.result(binding))
    }

    File.open("#{File.dirname(header)}/#{enum_name}_to_string.cpp", 'wb') { |built_cpp|
      built_cpp.write(template_cpp.result(binding))
    }
  }
}

Using regular expressions makes this "parser" quite fragile, it may not be able to handle your specific headers gracefully.

Let's say you have a header toto/a.h, containing definitions for enums MyEnum and MyEnum2. The script will build:

toto/MyEnum_to_string.h
toto/MyEnum_to_string.cpp
toto/MyEnum2_to_string.h
toto/MyEnum2_to_string.cpp

More robust solutions would be:

Build all sources defining enums and their operations from another source. This means you'll define your enums in a XML/YML/whatever file which is much easier to parse than C/C++.
Use a real compiler such as suggested by Avdi.
Use preprocessor macros with or without templates.

User · Answer

include  lt iostream gt   include  lt map gt   define IDMAP x   x  x   std  map lt int   std  string gt  enToStr  class mapEnumtoString   public      mapEnumtoString           mapEnumtoString amp  operator   int i std  string str                enToStr i    str          return  this        public     std  string operator     int i                return enToStr i             mapEnumtoString k  mapEnumtoString amp  init         return k     int main      init       IDMAP 1      IDMAP 2      IDMAP 3      IDMAP 4      IDMAP 5   std  cout lt  lt enToStr 1   std  cout lt  lt enToStr 2   std  cout lt  lt enToStr 3   std  cout lt  lt enToStr 4   std  cout lt  lt enToStr 5

User · Answer

Adding even more simplicity of use to Jasper Bekkers  fantastic answer   Set up once    define MAKE ENUM VAR  VAR   define MAKE STRINGS VAR   VAR   define MAKE ENUM AND STRINGS source  enumName  enumStringName        enum enumName         source MAKE ENUM            const char  const enumStringName             source MAKE STRINGS             Then  for usage    define SOME ENUM DO        DO Foo        DO Bar        DO Baz      MAKE ENUM AND STRINGS SOME ENUM  someEnum  someEnumNames

User · Answer

I just re-invented this wheel today  and thought I d share it   This implementation does not require any changes to the code that defines the constants  which can be enumerations or  defines or anything else that devolves to an integer - in my case I had symbols defined in terms of other symbols  It also works well with sparse values  It even allows multiple names for the same value  returning the first one always  The only downside is that it requires you to make a table of the constants  which might become out-of-date as new ones are added for example   struct IdAndName      int          id     const char   name     bool operator lt  const IdAndName  amp rhs  const   return id  lt  rhs id        define ID AND NAME x    x   x    const char   IdToName int id  IdAndName  table begin  IdAndName  table end       if   table end - table begin   gt  1  amp  amp  table begin 0  id  gt  table begin 1  id        std  stable sort table begin  table end       IdAndName searchee     id  NULL       IdAndName  p   std  lower bound table begin  table end  searchee      return  p    table end    p- gt id    id    NULL   p- gt name     template lt int N gt  const char   IdToName int id  IdAndName   amp table  N        return IdToName id   amp table 0    amp table N        An example of how you d use it   static IdAndName WindowsErrorTable          ID AND NAME INT MAX                    flag value to indicate unsorted table    ID AND NAME NO ERROR      ID AND NAME ERROR INVALID FUNCTION      ID AND NAME ERROR FILE NOT FOUND      ID AND NAME ERROR PATH NOT FOUND      ID AND NAME ERROR TOO MANY OPEN FILES      ID AND NAME ERROR ACCESS DENIED      ID AND NAME ERROR INVALID HANDLE      ID AND NAME ERROR ARENA TRASHED      ID AND NAME ERROR NOT ENOUGH MEMORY      ID AND NAME ERROR INVALID BLOCK      ID AND NAME ERROR BAD ENVIRONMENT      ID AND NAME ERROR BAD FORMAT      ID AND NAME ERROR INVALID ACCESS      ID AND NAME ERROR INVALID DATA      ID AND NAME ERROR INVALID DRIVE      ID AND NAME ERROR CURRENT DIRECTORY      ID AND NAME ERROR NOT SAME DEVICE      ID AND NAME ERROR NO MORE FILES      const char   error name   IdToName GetLastError    WindowsErrorTable     The IdToName function relies on std  lower bound to do quick lookups  which requires the table to be sorted  If the first two entries in the table are out of order  the function will sort it automatically   Edit  A comment made me think of another way of using the same principle  A macro simplifies the generation of a big switch statement    define ID AND NAME x  case x  return  x  const char   WindowsErrorToName int id        switch id                ID AND NAME ERROR INVALID FUNCTION           ID AND NAME ERROR FILE NOT FOUND           ID AND NAME ERROR PATH NOT FOUND           ID AND NAME ERROR TOO MANY OPEN FILES           ID AND NAME ERROR ACCESS DENIED           ID AND NAME ERROR INVALID HANDLE           ID AND NAME ERROR ARENA TRASHED           ID AND NAME ERROR NOT ENOUGH MEMORY           ID AND NAME ERROR INVALID BLOCK           ID AND NAME ERROR BAD ENVIRONMENT           ID AND NAME ERROR BAD FORMAT           ID AND NAME ERROR INVALID ACCESS           ID AND NAME ERROR INVALID DATA           ID AND NAME ERROR INVALID DRIVE           ID AND NAME ERROR CURRENT DIRECTORY           ID AND NAME ERROR NOT SAME DEVICE           ID AND NAME ERROR NO MORE FILES           default  return NULL

User · Answer

Note that your conversion function should ideally be returning a const char     If you can afford to put your enums in their separate header files  you could perhaps do something like this with macros  oh  this will be ugly     include  enum def h   include  colour h   include  enum conv h   include  colour h    Where enum def h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  enum NAME    define ENUM ADD NAME  VALUE  NAME   VALUE   define ENUM END      And enum conv h has    undef ENUM START  undef ENUM ADD  undef ENUM END  define ENUM START NAME  const char    NAME   to string NAME val    switch  val     define ENUM ADD NAME  VALUE  case NAME  return  NAME   define ENUM END default  return  Invalid value         And finally  colour h has   ENUM START colour  ENUM ADD red    0xff0000  ENUM ADD green  0x00ff00  ENUM ADD blue   0x0000ff  ENUM END   And you can use the conversion function as   printf   s   colour to string colour  red      This is ugly  but it s the only way  at the preprocessor level  that lets you define your enum just in a single place in your code  Your code is therefore not prone to errors due to modifications to the enum  Your enum definition and the conversion function will always be in sync  However  I repeat  this is ugly

User · Answer

This question is a duplicate of    How to easily map c   enums to strings   However  in none of the questions  I could find good answers   After delving into the topic  I found two great open source solutions   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    Note  I am repeating the recommendation here  This question has a lot of traffic views and really requires listing the solutions above

User · Answer

Another answer  in some contexts  it makes sense to define your enumeration in a non-code format  like a CSV  YAML  or XML file  and then generate both the C   enumeration code and the to-string code from the definition   This approach may or may not be practical in your application  but it s something to keep in mind

User · Answer

I do this with separate side-by-side enum wrapper classes which are generated with macros  There are several advantages    Can generate them for enums I don t define  eg  OS platform header enums  Can incorporate range checking into the wrapper class Can do  smarter  formatting with bit field enums   The downside  of course  is that I need to duplicate the enum values in the formatter classes  and I don t have any script to generate them  Other than that  though  it seems to work pretty well   Here s an example of an enum from my codebase  sans all the framework code which implements the macros and templates  but you can get the idea   enum EHelpLocation       HELP LOCATION UNKNOWN     0       HELP LOCAL FILE           1       HELP HTML ONLINE          2      class CEnumFormatter EHelpLocation   public CEnumDefaultFormatter lt  EHelpLocation  gt    public      static inline CString FormatEnum  EHelpLocation eValue                 switch   eValue                         ON CASE VALUE RETURN STRING OF VALUE  HELP LOCATION UNKNOWN                ON CASE VALUE RETURN STRING OF VALUE  HELP LOCAL FILE                ON CASE VALUE RETURN STRING OF VALUE  HELP HTML ONLINE            default              return FormatAsNumber  eValue                       DECLARE RANGE CHECK CLASS  EHelpLocation  CRangeInfoSequential lt  HELP HTML ONLINE  gt     typedef ESmartEnum lt  EHelpLocation  HELP LOCATION UNKNOWN  CEnumFormatter EHelpLocation  CRangeInfo EHelpLocation  gt  SEHelpLocation    The idea then is instead of using EHelpLocation  you use SEHelpLocation  everything works the same  but you get range checking and a  Format    method on the enum variable itself  If you need to format a stand-alone value  you can use CEnumFormatter EHelpLocation  FormatEnum        Hope this is helpful  I realize this also doesn t address the original question about a script to actually generate the other class  but I hope the structure helps someone trying to solve the same problem  or write such a script

User · Answer

I want to post this in case someone finds it useful    In my case  I simply need to generate ToString   and FromString   functions for a single C  11 enum from a single  hpp file   I wrote a python script that parses the header file containing the enum items and generates the functions in a new  cpp file    You can add this script in CMakeLists txt with execute process  or as a pre-build event in Visual Studio  The  cpp file will be automatically generated  without the need to manually update it each time a new enum item is added   generate enum strings py    This script is used to generate strings from C   enums  import re import sys import os  fileName   sys argv 1  enumName   os path basename os path splitext fileName  0    with open fileName   r   as f      content   f read   replace   n        searchResult   re search  enum                 content  tokens   searchResult group 2  tokens   tokens split      tokens   map str strip  tokens  tokens   map lambda token  re search    a-zA-Z0-9       token  group 1   tokens   textOut      textOut      n include      enumName     hpp  n n  textOut     namespace myns n  textOut       n  textOut         std  string ToString ErrorCode errorCode  n  textOut           n  textOut             switch  errorCode  n  textOut               n   for token in tokens      textOut             case     enumName          token      n      textOut                 return      token       n   textOut             default  n  textOut                 return  Last   n  textOut               n  textOut           n  textOut      n  textOut             enumName     FromString const std  string  amp errorCode  n  textOut           n  textOut             if       tokens 0          errorCode  n  textOut               n  textOut                 return     enumName          tokens 0       n  textOut               n   for token in tokens 1        textOut             else if      token         errorCode  n      textOut               n      textOut                 return     enumName          token      n      textOut               n   textOut      n  textOut             return     enumName      Last  n  textOut           n  textOut       n   fileOut   open enumName     cpp    w   fileOut write textOut    Example   ErrorCode hpp   pragma once   include  lt string gt   include  lt cstdint gt   namespace myns       enum class ErrorCode   uint32 t               OK   0          OutOfSpace          ConnectionFailure          InvalidJson          DatabaseFailure          HttpError          FileSystemError          FailedToEncrypt          FailedToDecrypt          EndOfFile          FailedToOpenFileForRead          FailedToOpenFileForWrite          FailedToLaunchProcess           Last             std  string ToString ErrorCode errorCode       ErrorCode FromString const std  string  amp errorCode       Run python generate enum strings py ErrorCode hpp  Result   ErrorCode cpp   include  ErrorCode hpp   namespace myns       std  string ToString ErrorCode errorCode                switch  errorCode                    case ErrorCode  OK              return  OK           case ErrorCode  OutOfSpace              return  OutOfSpace           case ErrorCode  ConnectionFailure              return  ConnectionFailure           case ErrorCode  InvalidJson              return  InvalidJson           case ErrorCode  DatabaseFailure              return  DatabaseFailure           case ErrorCode  HttpError              return  HttpError           case ErrorCode  FileSystemError              return  FileSystemError           case ErrorCode  FailedToEncrypt              return  FailedToEncrypt           case ErrorCode  FailedToDecrypt              return  FailedToDecrypt           case ErrorCode  EndOfFile              return  EndOfFile           case ErrorCode  FailedToOpenFileForRead              return  FailedToOpenFileForRead           case ErrorCode  FailedToOpenFileForWrite              return  FailedToOpenFileForWrite           case ErrorCode  FailedToLaunchProcess              return  FailedToLaunchProcess           case ErrorCode  Last              return  Last           default              return  Last                        ErrorCode FromString const std  string  amp errorCode                if   OK     errorCode                        return ErrorCode  OK                    else if  OutOfSpace     errorCode                        return ErrorCode  OutOfSpace                    else if  ConnectionFailure     errorCode                        return ErrorCode  ConnectionFailure                    else if  InvalidJson     errorCode                        return ErrorCode  InvalidJson                    else if  DatabaseFailure     errorCode                        return ErrorCode  DatabaseFailure                    else if  HttpError     errorCode                        return ErrorCode  HttpError                    else if  FileSystemError     errorCode                        return ErrorCode  FileSystemError                    else if  FailedToEncrypt     errorCode                        return ErrorCode  FailedToEncrypt                    else if  FailedToDecrypt     errorCode                        return ErrorCode  FailedToDecrypt                    else if  EndOfFile     errorCode                        return ErrorCode  EndOfFile                    else if  FailedToOpenFileForRead     errorCode                        return ErrorCode  FailedToOpenFileForRead                    else if  FailedToOpenFileForWrite     errorCode                        return ErrorCode  FailedToOpenFileForWrite                    else if  FailedToLaunchProcess     errorCode                        return ErrorCode  FailedToLaunchProcess                    else if  Last     errorCode                        return ErrorCode  Last                     return ErrorCode  Last

User · Answer

Another answer  in some contexts  it makes sense to define your enumeration in a non-code format  like a CSV  YAML  or XML file  and then generate both the C   enumeration code and the to-string code from the definition   This approach may or may not be practical in your application  but it s something to keep in mind

User · Answer

Here is a CLI program I wrote to easily convert enums to strings  Its easy to use  and takes about 5 seconds to get it done  including the time to cd to the directory containing the program  then run it  passing to it the file containing the enum    Download here  http   www mediafire com  nttignoozzz  Discussion topic on it here  http   cboard cprogramming com projects-job-recruitment 127488-free-program-im-sharing-convertenumtostrings html  Run the program with the  --help  argument to get a description how to use it

User · Answer

You could use a reflection library  like Ponder  You register the enums and then you can convert them back and forth with the API   enum class MyEnum       Zero   0      One    1      Two    2     ponder  Enum  declare lt MyEnum gt         value  Zero   MyEnum  Zero       value  One    MyEnum  One       value  Two    MyEnum  Two    ponder  EnumObject zero MyEnum  Zero    zero name       - gt   Zero

User · Answer

The following ruby script attempts to parse the headers and builts the required sources alongside the original headers.

#! /usr/bin/env ruby

# Let's "parse" the headers
# Note that using a regular expression is rather fragile
# and may break on some inputs

GLOBS = [
  "toto/*.h",
  "tutu/*.h",
  "tutu/*.hxx"
]

enums = {}
GLOBS.each { |glob|
  Dir[glob].each { |header|
    enums[header] = File.open(header, 'rb') { |f|
      f.read
    }.scan(/enum\s+(\w+)\s+\{\s*([^}]+?)\s*\}/m).collect { |enum_name, enum_key_and_values|
      [
        enum_name, enum_key_and_values.split(/\s*,\s*/).collect { |enum_key_and_value|
          enum_key_and_value.split(/\s*=\s*/).first
        }
      ]
    }
  }
}


# Now we build a .h and .cpp alongside the parsed headers
# using the template engine provided with ruby
require 'erb'

template_h = ERB.new <<-EOS
#ifndef <%= enum_name %>_to_string_h_
#define <%= enum_name %>_to_string_h_ 1

#include "<%= header %>"
char* enum_to_string(<%= enum_name %> e);

#endif
EOS

template_cpp = ERB.new <<-EOS
#include "<%= enum_name %>_to_string.h"

char* enum_to_string(<%= enum_name %> e)
{
  switch (e)
  {<% enum_keys.each do |enum_key| %>
    case <%= enum_key %>: return "<%= enum_key %>";<% end %>
    default: return "INVALID <%= enum_name %> VALUE";
  }
}
EOS

enums.each { |header, enum_name_and_keys|
  enum_name_and_keys.each { |enum_name, enum_keys|
    File.open("#{File.dirname(header)}/#{enum_name}_to_string.h", 'wb') { |built_h|
      built_h.write(template_h.result(binding))
    }

    File.open("#{File.dirname(header)}/#{enum_name}_to_string.cpp", 'wb') { |built_cpp|
      built_cpp.write(template_cpp.result(binding))
    }
  }
}

Using regular expressions makes this "parser" quite fragile, it may not be able to handle your specific headers gracefully.

Let's say you have a header toto/a.h, containing definitions for enums MyEnum and MyEnum2. The script will build:

toto/MyEnum_to_string.h
toto/MyEnum_to_string.cpp
toto/MyEnum2_to_string.h
toto/MyEnum2_to_string.cpp

More robust solutions would be:

Build all sources defining enums and their operations from another source. This means you'll define your enums in a XML/YML/whatever file which is much easier to parse than C/C++.
Use a real compiler such as suggested by Avdi.
Use preprocessor macros with or without templates.

User · Answer

Here is a CLI program I wrote to easily convert enums to strings  Its easy to use  and takes about 5 seconds to get it done  including the time to cd to the directory containing the program  then run it  passing to it the file containing the enum    Download here  http   www mediafire com  nttignoozzz  Discussion topic on it here  http   cboard cprogramming com projects-job-recruitment 127488-free-program-im-sharing-convertenumtostrings html  Run the program with the  --help  argument to get a description how to use it

User · Answer

I have an incredibly simple to use macro that does this in a completely DRY fashion  It involves variadic macros and some simple parsing magic  Here goes    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 this in your code  simply do   AWESOME MAKE ENUM Animal      DOG      CAT      HORSE

User · Answer

X-macros are the best solution  Example    include  lt iostream gt   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     std  ostream amp  operator lt  lt  std  ostream amp  os  enum Colours c        if  c  gt   ColoursCount    c  lt  0  return os  lt  lt             return os  lt  lt  colours str c      int main         std  cout  lt  lt  Red  lt  lt  Blue  lt  lt  Green  lt  lt  Cyan  lt  lt  Yellow  lt  lt  Magenta  lt  lt  std  endl      colours def   X Red  X Green  X Blue  X Cyan  X Yellow  X Magenta    However  I usually prefer the following method  so that it s possible to tweak the string a bit    define X a  b  a   define X a  b  b   X Red   red   X Green   green      etc

User · Answer

Suma s macro solution is nice  You don t need to have two different macro s  though  C   wil happily include a header twice  Just leave out the include guard   So you d have an foobar h defining just  ENUM Foo  1  ENUM Bar  2    and you would include it like this    define ENUMFACTORY ARGUMENT  foobar h   include  enumfactory h    enumfactory h will do 2  include ENUMFACTORY ARGUMENTs  In the first round  it expands ENUM like Suma s DECLARE ENUM  in the second round ENUM works like DEFINE ENUM   You can include enumfactory h multiple times  too  as long as you pass in different  define s for ENUMFACTORY ARGUMENT

User · Answer

hydroo  Without the extra file    define SOME ENUM DO        DO Foo        DO Bar        DO Baz    define MAKE ENUM VAR  VAR  enum MetaSyntacticVariable      SOME ENUM MAKE ENUM       define MAKE STRINGS VAR   VAR  const char  const MetaSyntacticVariableNames           SOME ENUM MAKE STRINGS

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

Another answer  in some contexts  it makes sense to define your enumeration in a non-code format  like a CSV  YAML  or XML file  and then generate both the C   enumeration code and the to-string code from the definition   This approach may or may not be practical in your application  but it s something to keep in mind

User · Answer

That s pretty much the only way it can be done  an array of string could work also    The problem is  once a C program is compiled  the binary value of the enum is all that is used  and the name is gone

User · Answer

This question is a duplicate of    How to easily map c   enums to strings   However  in none of the questions  I could find good answers   After delving into the topic  I found two great open source solutions   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    Note  I am repeating the recommendation here  This question has a lot of traffic views and really requires listing the solutions above

[c++] Is there a simple way to convert C++ enum to string?

Examples related to c++

Examples related to string

Examples related to enums

Examples related to scripting