How to convert an enum type variable to a string

Question

How to make printf to show the values of variables which are of an enum type  For instance   typedef enum  Linux  Apple  Windows  OS type   OS type myOS   Linux    and what I need is something like   printenum OS type   My OS is  s   myOS     which must show a string  Linux   not an integer   I suppose  first I have to create a value-indexed array of strings  But I don t know if that is the most beautiful way to do it  Is it possible at all

User · Answer

Did you try this    define stringify  name     name  enum enMyErrorValue       ERROR INVALIDINPUT   0    ERROR NULLINPUT    ERROR INPUTTOOMUCH    ERROR IAMBUSY       const char  enMyErrorValueNames            stringify  ERROR INVALIDINPUT      stringify  ERROR NULLINPUT      stringify  ERROR INPUTTOOMUCH      stringify  ERROR IAMBUSY         void vPrintError  enMyErrorValue enError         cout  lt  lt  enMyErrorValueNames  enError    lt  lt  endl       int main         vPrintError  enMyErrorValue 1         The stringify   macro can be used to turn any text in your code into a string  but only the exact text between the parentheses  There are no variable dereferencing or macro substitutions or any other sort of thing done   http   www cplusplus com forum general 2949

User · Answer

I m a bit late but here s my solution using g   and only standard libraries  I ve tried to minimise namespace pollution and remove any need to re-typing enum names   The header file  my enum hpp  is    include  lt cstring gt   namespace ENUM HELPERS      int replace commas and spaces with null char  string           int i  N          N   strlen string           for i 0  i lt N    i               if  isspace string i      string i                           string i    0                                   return N              int count words null delim char  string  int tot N           int i          int j 0          char last     0           for i 0 i lt tot N   i               if  last      0    amp  amp   string i     0                       j                            last   string i                     return j              int get null word offsets char  string  int tot N  int current w           int i          int j 0          char last     0           for i 0  i lt tot N    i               if  last    0    amp  amp   string i     0                     if j    current w                       return i                                       j                            last   string i                     return tot N     null value for offset            int find offsets int  offsets  char  string  int tot N  int N words           int i          for i 0  i lt N words    i               offsets i    get null word offsets string  tot N  i                     return 0              define MAKE ENUM NAME                                                    namespace NAME                                                                enum ENUM    VA ARGS                                                      char name holder        VA ARGS                                           int name holder N                                                             ENUM HELPERS  replace commas and spaces with null name holder         int N                                                                         ENUM HELPERS  count words null delim                                          name holder  name holder N                                        int offsets        VA ARGS                                                int ZERO                                                                      ENUM HELPERS  find offsets                                                    offsets  name holder  name holder N  N                            char  tostring int i                                                         return  amp name holder offsets i                                                                                                                    Example of use    include  lt cstdio gt   include  my enum hpp   MAKE ENUM Planets  MERCURY  VENUS  EARTH  MARS   int main int argc  char   argv           Planets  ENUM a planet   Planets  EARTH      printf   s n   Planets  tostring Planets  MERCURY        printf   s n   Planets  tostring a planet        This will output   MERCURY EARTH   You only have to define everything once  your namespace shouldn t be polluted  and all of the computation is only done once  the rest is just lookups   However  you don t get the type-safety of enum classes  they are still just short integers   you cannot assign values to the enums  you have to define enums somewhere you can define namespaces  e g  globally    I m not sure how good the performance on this is  or if it s a good idea  I learnt C before C   so my brain still works that way   If anyone knows why this is a bad idea feel free to point it out

User · Answer

A clean solution to this problem would be    define RETURN STR val  e   if  val    e   return  e     std  string conv dxgi format to string int value        RETURN STR value  DXGI FORMAT UNKNOWN       RETURN STR value  DXGI FORMAT R32G32B32A32 TYPELESS       RETURN STR value  DXGI FORMAT R32G32B32A32 FLOAT       RETURN STR value  DXGI FORMAT R32G32B32A32 UINT       RETURN STR value  DXGI FORMAT R32G32B32A32 SINT       RETURN STR value  DXGI FORMAT R32G32B32 TYPELESS       RETURN STR value  DXGI FORMAT R32G32B32 FLOAT                       return   lt UNKNOWN gt        The good thing about this solution is that it is simple and also constructing the function can be done easily via copy and replace  Note that if you are going to do a lot of conversions and your enum has too many possible values  this solution might become CPU intensive

User · Answer

This simple example worked for me  Hope this helps    include  lt iostream gt   include  lt string gt    define ENUM TO STR ENUM  std  string  ENUM   enum DIRECTION NORTH  SOUTH  WEST  EAST    int main       std  cout  lt  lt   Hello     lt  lt  ENUM TO STR NORTH   lt  lt     n     std  cout  lt  lt   Hello     lt  lt  ENUM TO STR SOUTH   lt  lt     n     std  cout  lt  lt   Hello     lt  lt  ENUM TO STR EAST   lt  lt     n     std  cout  lt  lt   Hello     lt  lt  ENUM TO STR WEST   lt  lt     n

User · Answer

Personally  I would go for something simple and use an operator to do so   Considering the following enum   enum WeekDay   MONDAY  TUESDAY  WEDNESDAY  THURSDAY  FRIDAY  SATURDAY  SUNDAY      We can create an operator to output the result in an std  ostream   std  ostream  amp operator lt  lt  std  ostream  amp stream  const WeekDay day      switch  day        case MONDAY        stream  lt  lt   Monday         break      case TUESDAY        stream  lt  lt   Tuesday         break      case WEDNESDAY        stream  lt  lt   Wednesday         break      case THURSDAY        stream  lt  lt   Thursday         break      case FRIDAY        stream  lt  lt   Friday         break      case SATURDAY        stream  lt  lt   Saturday         break      case SUNDAY        stream  lt  lt   Sunday         break         return stream      The boilerplate code is indeed pretty big compared to some other methods presented in this thread  Still  it has the avantage of being pretty straightforward and easy to use   std  cout  lt  lt   First day of the week is    lt  lt  WeekDay  Monday  lt  lt  std  endl

User · Answer

pragma once   include  lt string gt   include  lt vector gt   include  lt sstream gt   include  lt algorithm gt   namespace StringifyEnum   static std  string TrimEnumString const std  string  amp s        std  string  const iterator it   s begin        while  it    s end    amp  amp  isspace  it     it          std  string  const reverse iterator rit   s rbegin        while  rit base      it  amp  amp  isspace  rit       rit        return std  string it  rit base        static std  vector lt std  string gt  SplitEnumArgs const char  szArgs  int     nMax        std  vector lt std  string gt  enums      std  stringstream ss szArgs       std  string strSub      int nIdx   0      while  ss good    amp  amp   nIdx  lt  nMax             getline ss  strSub                enums push back StringifyEnum  TrimEnumString strSub              nIdx            return std  move enums             define DECLARE ENUM SEQ ename  n             enum class ename     VA ARGS            const int MAX NUMBER OF   ename n         static std  vector lt std  string gt  ename  Strings   StringifyEnum  SplitEnumArgs    VA ARGS    MAX NUMBER OF   ename         inline static std  string ename  ToString ename e              return ename  Strings at  int e                 inline static ename StringTo  ename const std  string amp  en              const auto it   std  find ename  Strings begin    ename  Strings end    en             if  it    ename  Strings end                  return  ename  std  distance ename  Strings begin    it             throw std  runtime error  Could not resolve string enum value                  This is an elaborated class extended enum version   it does not add any other enum value other than those provided   Usage  DECLARE ENUM SEQ CameraMode   3   Fly  FirstPerson  PerspectiveCorrect

User · Answer

It s 2017 but the question is still alive  Yet another way    include  lt iostream gt    define ERROR VALUES   ERROR VALUE NO ERROR  0   OK     ERROR VALUE FILE NOT FOUND  1   Not found     ERROR VALUE LABEL UNINITIALISED  2   Uninitialized usage    enum Error    define ERROR VALUE NAME  VALUE  TEXT  NAME   VALUE      ERROR VALUES  undef ERROR VALUE     inline std  ostream amp  operator lt  lt  std  ostream amp  os  Error err        int errVal   static cast lt int gt  err       switch  err         define ERROR VALUE NAME  VALUE  TEXT  case NAME  return os  lt  lt       lt  lt  errVal  lt  lt       lt  lt   NAME  lt  lt        lt  lt  TEXT      ERROR VALUES  undef ERROR VALUE     default             If the error value isn t found  shouldn t happen          return os  lt  lt  errVal           int main         std  cout  lt  lt   Error     lt  lt  NO ERROR  lt  lt  std  endl      std  cout  lt  lt   Error     lt  lt  FILE NOT FOUND  lt  lt  std  endl      std  cout  lt  lt   Error     lt  lt  LABEL UNINITIALISED  lt  lt  std  endl      return 0      Outputs   Error   0 NO ERROR  OK Error   1 FILE NOT FOUND  Not found Error   2 LABEL UNINITIALISED  Uninitialized usage

User · Answer

Another late to the party  using the preprocessor    1   define MY ENUM LIST    2      DEFINE ENUM ELEMENT First     3      DEFINE ENUM ELEMENT Second     4      DEFINE ENUM ELEMENT Third     5    6    --------------------------------------  7   define DEFINE ENUM ELEMENT name    name  8  enum MyEnum    9      Zeroth   0 10      MY ENUM LIST 11     12   undef DEFINE ENUM ELEMENT 13  14   define DEFINE ENUM ELEMENT name     name 15  const char  MyEnumToString       16       Zeroth  17      MY ENUM LIST 18     19   undef DEFINE ENUM ELEMENT 20 21   define DEFINE ENUM ELEMENT name  else if  strcmp s   name   0  return name  22  enum MyEnum StringToMyEnum const char  s   23      if  strcmp s   Zeroth    0  return Zeroth  24      MY ENUM LIST 25      return NULL  26    27   undef DEFINE ENUM ELEMENT    I just put in line numbers so it s easier to talk about   Lines 1-4 are what you edit to define the elements of the enum   I have called it a  list macro   because it s a macro that makes a list of things   Lundin informs me these are a well-known technique called X-macros    Line 7 defines the inner macro so as to fill in the actual enum declaration in lines 8-11  Line 12 undefines the inner macro  just to silence the compiler warning    Line 14 defines the inner macro so as to create a string version of the enum element name  Then lines 15-18 generate an array that can convert an enum value to the corresponding string   Lines 21-27 generate a function that converts a string to the enum value  or returns NULL if the string doesn t match any   This is a little cumbersome in the way it handles the 0th element  I ve actually worked around that in the past   I admit this technique bothers people who don t want to think the preprocessor itself can be programmed to write code for you  I think it strongly illustrates the difference between readability and maintainability  The code is difficult to read  but if the enum has a few hundred elements  you can add  remove  or rearrange elements and still be sure the generated code has no errors

User · Answer

My solution  not using boost    ifndef EN2STR HXX   define EN2STR HXX    define MAKE STRING 1 str        str  define MAKE STRING 2 str        str  MAKE STRING 1   VA ARGS     define MAKE STRING 3 str        str  MAKE STRING 2   VA ARGS     define MAKE STRING 4 str        str  MAKE STRING 3   VA ARGS     define MAKE STRING 5 str        str  MAKE STRING 4   VA ARGS     define MAKE STRING 6 str        str  MAKE STRING 5   VA ARGS     define MAKE STRING 7 str        str  MAKE STRING 6   VA ARGS     define MAKE STRING 8 str        str  MAKE STRING 7   VA ARGS      define PRIMITIVE CAT a  b  a  b  define MAKE STRING N       PRIMITIVE CAT MAKE STRING   N         VA ARGS       define PP RSEQ N   8 7 6 5 4 3 2 1 0  define PP ARG N  1  2  3  4  5  6  7  8 N      N  define PP NARG       PP ARG N   VA ARGS     define PP NARG       PP NARG    VA ARGS   PP RSEQ N      define MAKE ENUM NAME       enum NAME     VA ARGS                     struct NAME   str                                                      static const char   get const NAME et                                  static const char  NAME  Str                                                   MAKE STRING PP NARG   VA ARGS       VA ARGS                return NAME  Str et                                                                                                                          endif    EN2STR HXX       And here is how to use it  int main         MAKE ENUM pippo  pp1  pp2  pp3 a s d     pippo c   d    cout  lt  lt  pippo str  get c   lt  lt    n     return 0

User · Answer

The naive solution  of course  is to write a function for each enumeration that performs the conversion to string   enum OS type   Linux  Apple  Windows     inline const char  ToString OS type v        switch  v                case Linux    return  Linux           case Apple    return  Apple           case Windows  return  Windows           default       return   Unknown OS type              This  however  is a maintenance disaster   With the help of the Boost Preprocessor library  which can be used with both C and C   code  you can easily take advantage of the preprocessor and let it generate this function for you   The generation macro is as follows    include  lt boost preprocessor hpp gt    define X DEFINE ENUM WITH STRING CONVERSIONS TOSTRING CASE r  data  elem           case elem   return BOOST PP STRINGIZE elem     define DEFINE ENUM WITH STRING CONVERSIONS name  enumerators                       enum name                                                                           BOOST PP SEQ ENUM enumerators                                                                                                                                                                                                               inline const char  ToString name v                                                                                                                                  switch  v                                                                                                                                                           BOOST PP SEQ FOR EACH                                                               X DEFINE ENUM WITH STRING CONVERSIONS TOSTRING CASE                             name                                                                            enumerators                                                                                                                                                 default  return   Unknown   BOOST PP STRINGIZE name                                                                                                         The first macro  beginning with X   is used internally by the second   The second macro first generates the enumeration  then generates a ToString function that takes an object of that type and returns the enumerator name as a string  this implementation  for obvious reasons  requires that the enumerators map to unique values      In C   you could implement the ToString function as an operator lt  lt  overload instead  but I think it s a bit cleaner to require an explicit  ToString  to convert the value to string form   As a usage example  your OS type enumeration would be defined as follows   DEFINE ENUM WITH STRING CONVERSIONS OS type   Linux  Apple  Windows     While the macro looks at first like it is a lot of work  and the definition of OS type looks rather foreign  remember that you have to write the macro once  then you can use it for every enumeration   You can add additional functionality to it  e g   a string-form to enum conversion  without too much trouble  and it completely solves the maintenance problem  since you only have to provide the names once  when you invoke the macro   The enumeration can then be used as if it were defined normally    include  lt iostream gt   int main         OS type t   Windows      std  cout  lt  lt  ToString t   lt  lt       lt  lt  ToString Apple   lt  lt  std  endl      The code snippets in this post  beginning with the  include  lt boost preprocessor hpp gt  line  can be compiled as posted to demonstrate the solution     This particular solution is for C   as it uses C  -specific syntax  e g   no typedef enum  and function overloading  but it would be straightforward to make this work with C as well

User · Answer

My own answer  not using boost - using my own approach without heavy define magic  and this solution has a limitation of not be able to define specific enum value    pragma once  include  lt string gt   template  lt class Enum gt  class EnumReflect   public      static const char  getEnums     return            define DECLARE ENUM name                                                     enum name     VA ARGS                                                     template  lt  gt                                                                class EnumReflect lt   name gt                                                  public                                                                        static const char  getEnums     return    VA ARGS                                Basic usage       Declare enumeration   DECLARE ENUM  enumName       enumValue1      enumValue2      enumValue3          comment     enumValue4         Conversion logic       From enumeration to string           printf  EnumToString enumValue3  c str           From string to enumeration          enumName value          if   StringToEnum  enumValue4   value                printf  Conversion failed            WARNING  At the moment assigning enum value to specific number is not supported             Converts enumeration to string  if not found - empty string is returned     template  lt class T gt  std  string EnumToString T t        const char  enums   EnumReflect lt T gt   getEnums        const char  token   next   enums - 1      int id    int t       do               token   next   1          if   token         token            next   strchr token                if   next  next   token   strlen token            if  id    0              return std  string token  next           id--        while   next    0        return std  string              Converts string to enumeration  if not found - false is returned     template  lt class T gt  bool StringToEnum const char  enumName  T amp  t        const char  enums   EnumReflect lt T gt   getEnums        const char  token   next   enums - 1      int id   0       do               token   next   1          if   token         token            next   strchr token                if   next  next   token   strlen token            if  strncmp token  enumName  next - token     0                        t    T id              return true                     id          while   next    0        return false      Latest version can be found on github in here   https   github com tapika cppscriptcore blob master SolutionProjectModel EnumReflect h

User · Answer

A little late to the party  but here s my C  11 solution   namespace std       template lt  gt  struct hash lt enum one gt            std  size t operator   const enum one  amp  e  const               return static cast lt std  size t gt  e                        template lt  gt  struct hash lt enum two gt      repeat for each enum type         std  size t operator   const enum two  amp  e  const               return static cast lt std  size t gt  e                       const std  string  amp  enum name const enum one  amp  e        static const std  unordered map lt enum one  const std  string gt  names          define v name n   enum one  n  std  string  n           v name value1           v name value2           v name value3       undef v name            return names at e      const std  string  amp  enum name const enum two  amp  e      repeat for each enum type

User · Answer

include  lt EnumString h gt    from http   www codeproject com Articles 42035 Enum-to-String-and-Vice-Versa-in-C and after  enum FORM       F NONE   0      F BOX      F CUBE      F SPHERE       insert  Begin Enum String  FORM         Enum String  F NONE        Enum String  F BOX        Enum String  F CUBE        Enum String  F SPHERE      End Enum String    Works fine if values in the enum are not duplicate   Sample code for converting an enum value to string   enum FORM f       const std  string amp  str   EnumString lt  FORM  gt   From  f      Sample code for just the opposite   assert  EnumString lt  FORM  gt   To  f  str

User · Answer

Clean  safe solution in pure standard C    include  lt stdio h gt    define STRF x   x  define STRINGIFY x  STRF x      list of enum constants     define TEST 0 hello  define TEST 1 world  typedef enum     TEST 0    TEST 1    TEST N   test t   const char  test str        STRINGIFY TEST 0     STRINGIFY TEST 1       int main          Static assert sizeof test str   sizeof  test str    TEST N                     Incorrect number of items in enum or look-up table       printf   d  s n   hello  test str hello      printf   d  s n   world  test str world      test t x   world    printf   d  s n   x  test str x       return 0        Output  0 hello 1 world 1 world     Rationale  When solving the core problem  have enum constants with corresponding strings   a sensible programmer will come up with the following requirements    Avoid code repetition   DRY  principle   The code must be scalable  maintainable and safe even if items are added or removed inside the enum  All code should be of high quality  easy to read  easy to maintain    The first requirement  and maybe also the second  can be fulfilled with various messy macro solutions such as the infamous  x macro  trick  or other forms of macro magic  The problem with such solutions is that they leave you with a completely unreadable mess of mysterious macros - they don t meet the third requirement above   The only thing needed here is actually to have a string look-up table  which we can access by using the enum variable as index  Such a table must naturally correspond directly to the enum and vice versa  When one of them is updated  the other has to be updated too  or it will not work     Explanation of the code  Suppose we have an enum like  typedef enum     hello    world   test t    This can be changed to    define TEST 0 hello  define TEST 1 world  typedef enum     TEST 0    TEST 1    test t    With the advantage that these macro constants can now be used elsewhere  to for example generate a string look-up table  Converting a pre-processor constant to a string can be done with a  stringify  macro    define STRF x   x  define STRINGIFY x  STRF x   const char  test str        STRINGIFY TEST 0     STRINGIFY TEST 1        And that s it  By using hello  we get the enum constant with value 0  By using test str hello  we get the string  hello    To make the enum and look-up table correspond directly  we have to ensure that they contain the very same amount of items  If someone would maintain the code and only change the enum  and not the look-up table  or vice versa  this method won t work   The solution is to have the enum to tell you how many items it contains  There is a commonly-used C trick for this  simply add an item at the end  which only fills the purpose of telling how many items the enum has   typedef enum     TEST 0    TEST 1    TEST N     will have value 2  there are 2 enum constants in this enum   test t    Now we can check at compile time that the number of items in the enum is as many as the number of items in the look-up table  preferably with a C11 static assert    Static assert sizeof test str   sizeof  test str    TEST N                   Incorrect number of items in enum or look-up table       There are ugly but fully-functional ways to create static asserts in older versions of the C standard too  if someone insists on using dinosaur compilers  As for C    it supports static asserts too      As a side note  in C11 we can also achieve higher type safety by changing the stringify macro    define STRINGIFY x   Generic  x   int   STRF x      int because enumeration constants are actually of type int  not test t   This will prevent code like STRINGIFY random stuff  from compiling

User · Answer

This is the pre processor block   ifndef GENERATE ENUM STRINGS      define DECL ENUM ELEMENT  element   element      define BEGIN ENUM  ENUM NAME   typedef enum tag  ENUM NAME      define END ENUM  ENUM NAME   ENUM NAME                char  GetString  ENUM NAME enum tag  ENUM NAME index    else      define DECL ENUM ELEMENT  element    element      define BEGIN ENUM  ENUM NAME   char  gs   ENUM NAME           define END ENUM  ENUM NAME     char  GetString  ENUM NAME enum               tag  ENUM NAME index   return gs   ENUM NAME  index      endif   Enum definition   BEGIN ENUM Os type        DECL ENUM ELEMENT winblows       DECL ENUM ELEMENT hackintosh     END ENUM Os type    Call using   GetStringOs type winblows     Taken from here  How cool is that

User · Answer

Assuming that your enum is already defined  you can create an array of pairs   std  pair lt QTask  TASK  QString gt  pairs        std  pair lt OS type  string gt  Linux   Linux    std  pair lt OS type  string gt  Windows   Windows    std  pair lt OS type  string gt  Apple   Apple         Now  you can create a map   std  map lt OS type  std  string gt  stdmap pairs  pairs   sizeof pairs    sizeof pairs 0       Now  you can use the map  If your enum is changed  you have to add remove pair from array pairs    I thinkk that it is the most elegant way to obtain a string from enum in C

User · Answer

There are lots of good answers already  but magic enum is worth a look  It describes itself as -  Static reflection for enums  to string  from string  iteration  for modern C    work with any enum type without any macro or boilerplate code  Header-only C  17 library provides static reflection for enums  work with any enum type without any macro or boilerplate code   Example usage enum Color   RED   2  BLUE   4  GREEN   8      Color color   Color  RED  auto color name   magic enum  enum name color      color name - gt   quot RED quot   std  string color name  quot GREEN quot    auto color   magic enum  enum cast lt Color gt  color name   if  color has value           color value   - gt  Color  GREEN

User · Answer

I have added one answer  which was not supporting enumeration values  now added support which supports enumeration value assignment as well  Like in previous solution this one uses minimum define magic   Here is header file    pragma once  include  lt string gt   include  lt map gt   include  lt regex gt   template  lt class Enum gt  class EnumReflect   public      static const char  getEnums     return                  Just a container for each enumeration type     template  lt class Enum gt  class EnumReflectBase   public      static std  map lt std  string  int gt  enum2int      static std  map lt int  std  string gt  int2enum       static void EnsureEnumMapReady  const char  enumsInfo                 if   enumsInfo    0    enum2int size      0               return              Should be called once per each enumeration          std  string senumsInfo enumsInfo           std  regex re     a-zA-Z   a-zA-Z0-9                                   C   identifier to optional      lt value gt           std  smatch sm          int value   0           for    regex search senumsInfo  sm  re   senumsInfo   sm suffix    value                          string enumName   sm 1  str                string enumValue   sm 2  str                 if  enumValue length      0                  value   atoi enumValue c str                  enum2int enumName    value              int2enum value    enumName                      template  lt class Enum gt  std  map lt std  string  int gt  EnumReflectBase lt Enum gt   enum2int   template  lt class Enum gt  std  map lt int  std  string gt  EnumReflectBase lt Enum gt   int2enum     define DECLARE ENUM name                                                     enum name     VA ARGS                                                     template  lt  gt                                                                class EnumReflect lt   name gt   public EnumReflectBase lt   name gt                  public                                                                        static const char  getEnums     return    VA ARGS                                   Basic usage       Declare enumeration   DECLARE ENUM  enumName       enumValue1      enumValue2      enumValue3   5          comment     enumValue4         Conversion logic       From enumeration to string           printf  EnumToString enumValue3  c str           From string to enumeration          enumName value          if   StringToEnum  enumValue4   value                printf  Conversion failed                  Converts enumeration to string  if not found - empty string is returned     template  lt class T gt  std  string EnumToString T t        EnumReflect lt T gt   EnsureEnumMapReady EnumReflect lt T gt   getEnums         auto amp  int2enum   EnumReflect lt T gt   int2enum      auto it   int2enum find t        if  it    int2enum end            return          return it- gt second            Converts string to enumeration  if not found - false is returned     template  lt class T gt  bool StringToEnum const char  enumName  T amp  t        EnumReflect lt T gt   EnsureEnumMapReady EnumReflect lt T gt   getEnums         auto amp  enum2int   EnumReflect lt T gt   enum2int      auto it   enum2int find enumName        if  it    enum2int end            return false       t    T  it- gt second      return true      And here is example test application   DECLARE ENUM TestEnum      ValueOne      ValueTwo      ValueThree   5      ValueFour   7     DECLARE ENUM TestEnum2      ValueOne2   -1      ValueTwo2      ValueThree2   -4      ValueFour2     void main void        string sName1   EnumToString ValueOne       string sName2   EnumToString ValueTwo       string sName3   EnumToString ValueThree       string sName4   EnumToString ValueFour        TestEnum t1  t2  t3  t4  t5   ValueOne      bool b1   StringToEnum sName1 c str    t1       bool b2   StringToEnum sName2 c str    t2       bool b3   StringToEnum sName3 c str    t3       bool b4   StringToEnum sName4 c str    t4       bool b5   StringToEnum  Unknown   t5        string sName2 1   EnumToString ValueOne2       string sName2 2   EnumToString ValueTwo2       string sName2 3   EnumToString ValueThree2       string sName2 4   EnumToString ValueFour2        TestEnum2 t2 1  t2 2  t2 3  t2 4  t2 5   ValueOne2      bool b2 1   StringToEnum sName2 1 c str    t2 1       bool b2 2   StringToEnum sName2 2 c str    t2 2       bool b2 3   StringToEnum sName2 3 c str    t2 3       bool b2 4   StringToEnum sName2 4 c str    t2 4       bool b2 5   StringToEnum  Unknown   t2 5     Updated version of same header file will be kept here   https   github com tapika cppreflect blob master cppreflect enumreflect h

User · Answer

Thanks James for your suggestion  It was very useful so I implemented the other way around to contribute in some way    include  lt iostream gt   include  lt boost preprocessor hpp gt   using namespace std    define X DEFINE ENUM WITH STRING CONVERSIONS TOSTRING CASE r  data   elem        case data  elem   return BOOST PP STRINGIZE elem     define X DEFINE ENUM WITH STRING CONVERSIONS TOENUM IF r  data  elem        if  BOOST PP SEQ TAIL data                                                       BOOST PP STRINGIZE elem   return                                         static cast lt int gt  BOOST PP SEQ HEAD data   elem   else   define DEFINE ENUM WITH STRING CONVERSIONS name  enumerators                enum class name                                                              BOOST PP SEQ ENUM enumerators                                                                                                                                                                                          inline const char  ToString name v                                                                                                                    switch  v                                                                                                                                             BOOST PP SEQ FOR EACH                                                        X DEFINE ENUM WITH STRING CONVERSIONS TOSTRING CASE                      name                                                                     enumerators                                                                                                                                   default  return   Unknown   BOOST PP STRINGIZE name                                                                                                                                                                                                                                         inline int ToEnum std  string s                                                                                                                       BOOST PP SEQ FOR EACH                                                            X DEFINE ENUM WITH STRING CONVERSIONS TOENUM IF                           name  s                                                                 enumerators                                                                                                                               return -1                                                                DEFINE ENUM WITH STRING CONVERSIONS OS type   Linux  Apple  Windows     int main void        OS type t   OS type  Windows       cout  lt  lt  ToString t   lt  lt       lt  lt  ToString OS type  Apple   lt  lt       lt  lt  ToString OS type  Linux   lt  lt  endl       cout  lt  lt  ToEnum  Windows    lt  lt       lt  lt  ToEnum  Apple    lt  lt       lt  lt  ToEnum  Linux    lt  lt  endl       return 0

User · Answer

What I made is a combination of what I have seen here and in similar questions on this site  I made this is Visual Studio 2013  I have not tested it with other compilers   First of all I define a set of macros that will do the tricks      concatenation macros  define CONCAT  A  B  A    B  define CONCAT A  B   CONCAT  A  B      generic expansion and stringification macros  define EXPAND X            X  define STRINGIFY ARG        ARG  define EXPANDSTRING ARG    STRINGIFY ARG              number of arguments macros  define NUM ARGS  X100  X99  X98  X97  X96  X95  X94  X93  X92  X91  X90  X89  X88  X87  X86  X85  X84  X83  X82  X81  X80  X79  X78  X77  X76  X75  X74  X73  X72  X71  X70  X69  X68  X67  X66  X65  X64  X63  X62  X61  X60  X59  X58  X57  X56  X55  X54  X53  X52  X51  X50  X49  X48  X47  X46  X45  X44  X43  X42  X41  X40  X39  X38  X37  X36  X35  X34  X33  X32  X31  X30  X29  X28  X27  X26  X25  X24  X23  X22  X21  X20  X19  X18  X17  X16  X15  X14  X13  X12  X11  X10  X9  X8  X7  X6  X5  X4  X3  X2  X1  N       N  define NUM ARGS      EXPAND NUM ARGS    VA ARGS    100  99  98  97  96  95  94  93  92  91  90  89  88  87  86  85  84  83  82  81  80  79  78  77  76  75  74  73  72  71  70  69  68  67  66  65  64  63  62  61  60  59  58  57  56  55  54  53  52  51  50  49  48  47  46  45  44  43  42  41  40  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10  9  8  7  6  5  4  3  2  1       argument extraction macros  define FIRST ARG ARG       ARG  define REST ARGS ARG         VA ARGS       arguments to strings macros  define ARGS STR   N        ARGS STR   N   VA ARGS     define ARGS STR  N         ARGS STR   N    VA ARGS     define ARGS STR            ARGS STR  NUM ARGS   VA ARGS       VA ARGS      define ARGS STR 1 ARG      EXPANDSTRING ARG   define ARGS STR 2          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 1 EXPAND REST ARGS   VA ARGS       define ARGS STR 3          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 2 EXPAND REST ARGS   VA ARGS       define ARGS STR 4          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 3 EXPAND REST ARGS   VA ARGS       define ARGS STR 5          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 4 EXPAND REST ARGS   VA ARGS       define ARGS STR 6          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 5 EXPAND REST ARGS   VA ARGS       define ARGS STR 7          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 6 EXPAND REST ARGS   VA ARGS       define ARGS STR 8          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 7 EXPAND REST ARGS   VA ARGS       define ARGS STR 9          EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 8 EXPAND REST ARGS   VA ARGS       define ARGS STR 10         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 9 EXPAND REST ARGS   VA ARGS       define ARGS STR 11         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 10 EXPAND REST ARGS   VA ARGS       define ARGS STR 12         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 11 EXPAND REST ARGS   VA ARGS       define ARGS STR 13         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 12 EXPAND REST ARGS   VA ARGS       define ARGS STR 14         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 13 EXPAND REST ARGS   VA ARGS       define ARGS STR 15         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 14 EXPAND REST ARGS   VA ARGS       define ARGS STR 16         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 15 EXPAND REST ARGS   VA ARGS       define ARGS STR 17         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 16 EXPAND REST ARGS   VA ARGS       define ARGS STR 18         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 17 EXPAND REST ARGS   VA ARGS       define ARGS STR 19         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 18 EXPAND REST ARGS   VA ARGS       define ARGS STR 20         EXPANDSTRING FIRST ARG   VA ARGS      ARGS STR 19 EXPAND REST ARGS   VA ARGS         expand until  100 or as much as you need   Next define a single macro that will create the enum class and the functions to get the strings    define ENUM NAME                                                                                                         enum class NAME                                                                                                                                                                                                                                   VA ARGS                                                                                                                                                                                                                                                                                                                                                     static const std  array lt std  string  NUM ARGS   VA ARGS    gt  CONCAT NAME  Strings      ARGS STR   VA ARGS                                                                                                                                    inline const std  string amp  ToString NAME value                                                                                                                                                                                                   return CONCAT NAME  Strings  static cast lt std  underlying type lt NAME gt   type gt  value                                                                                                                                                                                                                                                                              inline std  ostream amp  operator lt  lt  std  ostream amp  os  NAME value                                                                                                                                                                                    os  lt  lt  ToString value                                                                                                  return os                                                                                                             Now defining an enum type and have strings for it becomes really easy  All you need to do is   ENUM MyEnumType  A  B  C     The following lines can be used to test it   int main         std  cout  lt  lt  MyEnumTypeStrings size    lt  lt  std  endl       std  cout  lt  lt  ToString MyEnumType  A   lt  lt  std  endl      std  cout  lt  lt  ToString MyEnumType  B   lt  lt  std  endl      std  cout  lt  lt  ToString MyEnumType  C   lt  lt  std  endl       std  cout  lt  lt  MyEnumType  A  lt  lt  std  endl      std  cout  lt  lt  MyEnumType  B  lt  lt  std  endl      std  cout  lt  lt  MyEnumType  C  lt  lt  std  endl       auto myVar   MyEnumType  A      std  cout  lt  lt  myVar  lt  lt  std  endl      myVar   MyEnumType  B      std  cout  lt  lt  myVar  lt  lt  std  endl      myVar   MyEnumType  C      std  cout  lt  lt  myVar  lt  lt  std  endl       return 0      This will output   3 A B C A B C A B C   I believe it is very clean and easy to use  There are some limitations    You cannot assign values to the enum members  The enum member s values are used as index  but that should be fine  because everything is defined in a single macro  You cannot use it to define an enum type inside a class    If you can work around this  I think  especially how to use it  this is nice and lean  Advantages    Easy to use  No string splitting at runtime required  Separate strings are available at compile time  Easy to read  The first set of macros may need an extra second  but aren t really that complicated

User · Answer

There are many other answers to this but I think a better way is to use C  17 features and to use constexpr so that translations are done at compile time  This is type safe and we do not need to mess with macros  See below     enum hpp  include  lt array gt   include  lt string view gt   namespace Enum    template  lt class ENUM TYPE  size t SIZE gt  constexpr ENUM TYPE findKey const char   value  std  array lt std  pair lt ENUM TYPE  const char   gt   SIZE gt  map  size t index   -1        index    index    -1    map size     index      return          index    0    throw  Value not in map            std  string view map index - 1  second     value    map index- 1  first          findKey value  map  index - 1       template  lt class ENUM TYPE  size t SIZE gt  constexpr const char   findValue ENUM TYPE key  std  array lt std  pair lt ENUM TYPE  const char   gt   SIZE gt  map  size t index   -1        index    index    -1    map size     index      return          index    0    throw  Key not in map            map index - 1  first    key    map index- 1  second          findValue key  map  index - 1            test enum hpp  include  enum hpp   namespace TestEnum       enum class Fields               Test1          Test2          Test3            This has to be at the end         NUMBER OF FIELDS             constexpr std  array lt std  pair lt Fields  const char   gt    size t Fields  NUMBER OF FIELDS gt  GetMap                 std  array lt std  pair lt Fields  const char   gt    size t Fields  NUMBER OF FIELDS gt  map                                                Fields  Test1   Test1                         Fields  Test2   Test2                         Fields  Test3   Test3                                     return map              constexpr Fields StringToEnum const char   value                return Enum  findKey value  GetMap                constexpr const char   EnumToString Fields key                return Enum  findValue key  GetMap                This can then easily be used so that string key errors are detected at compile time    include  test enum hpp   int main         auto constexpr a   TestEnum  StringToEnum  Test2      a   TestEnum  Fields  Test2     auto constexpr b   TestEnum  EnumToString TestEnum  Fields  Test1     b    Test1      auto constexpr c   TestEnum  StringToEnum  AnyStringNotInTheMap      compile time failure     return 0      The code is more verbose than some other solutions but we can easily do Enum to String conversion and String to Enum conversion at compile time and detect type errors  With some of the future C  20 features this can probably be simplified a bit more

User · Answer

Here is my C   code          File    main cpp    Author  y2k1234       Created on June 14  2013  9 50 AM       include  lt cstdlib gt   include  lt stdio h gt   using namespace std     define MESSAGE LIST OPERATOR                                                                    OPERATOR MSG A                                            OPERATOR MSG B                                            OPERATOR MSG C   define GET LIST VALUE OPERATOR msg    ERROR   msg   VALUE  define GET LIST SRTING OPERATOR msg    ERROR   msg  NAME   enum ErrorMessagesEnum      MESSAGE LIST GET LIST VALUE OPERATOR     static const char  ErrorMessagesName           MESSAGE LIST GET LIST SRTING OPERATOR      int main int argc  char   argv          int totalMessages   sizeof ErrorMessagesName  4       for  int i   0  i  lt  totalMessages  i                  if  i    ERROR MSG A VALUE                            printf   ERROR MSG A VALUE   gt    d    s  n   i  ErrorMessagesName i                      else if  i    ERROR MSG B VALUE                            printf   ERROR MSG B VALUE   gt    d    s  n   i  ErrorMessagesName i                      else if  i    ERROR MSG C VALUE                            printf   ERROR MSG C VALUE   gt    d    s  n   i  ErrorMessagesName i                      else                           printf         gt    d    s  n   i  ErrorMessagesName i                            return 0     Output   ERROR MSG A VALUE   gt   0   ERROR MSG A NAME   ERROR MSG B VALUE   gt   1   ERROR MSG B NAME   ERROR MSG C VALUE   gt   2   ERROR MSG C NAME   RUN SUCCESSFUL  total time  126ms

User · Answer

My own preference is to minimize both repetitive typing and hard to understand macros and to avoid introducing macro definitions into the general compiler space   So  in the header file   enum Level                        zero reserved for internal use                    verbose   1          trace          debug          info          warn          fatal         static Level readLevel const char       and the cpp implementation is    Logger  Level Logger  readLevel const char  in         define MATCH x  if  strcmp in  x    0  return x       MATCH verbose       MATCH trace       MATCH debug       MATCH info       MATCH warn       MATCH fatal      undef MATCH     std  string s  No match for logging level         s    in      throw new std  domain error s        Note the  undef of the macro as soon we re done with it

User · Answer

There really is no beautiful way of doing this  Just set up an array of strings indexed by the enum   If you do a lot of output  you can define an operator lt  lt  that takes an enum parameter and does the lookup for you

User · Answer

For C99 there is P99 DECLARE ENUM in P99 that lets you simply declare enum like this   P99 DECLARE ENUM color  red  green  blue     and then use color getname A  to obtain a string with the color name

User · Answer

To extend James  answer  someone want some example code to support enum define with int value  I also have this requirement  so here is my way   First one the is internal use macro  which is used by FOR EACH    define DEFINE ENUM WITH STRING CONVERSIONS EXPAND VALUE r  data  elem                BOOST PP IF                                                                           BOOST PP EQUAL BOOST PP TUPLE SIZE elem   2                                       BOOST PP TUPLE ELEM 0  elem    BOOST PP TUPLE ELEM 1  elem                        BOOST PP TUPLE ELEM 0  elem       And  here is the define macro    define DEFINE ENUM WITH STRING CONVERSIONS name  enumerators                         enum name                                                                             BOOST PP SEQ FOR EACH DEFINE ENUM WITH STRING CONVERSIONS EXPAND VALUE                                  0  enumerators       So when using it  you may like to write like this   DEFINE ENUM WITH STRING CONVERSIONS MyEnum        FIRST  1         SECOND         MAX  SECOND       which will expand to   enum MyEnum       FIRST   1      SECOND      MAX   SECOND       The basic idea is to define a SEQ  which every element is a TUPLE  so we can put addition value for enum member  In FOR EACH loop  check the item TUPLE size  if the size is 2  expand the code to KEY   VALUE  else just keep the first element of TUPLE   Because the input SEQ is actually TUPLEs  so if you want to define STRINGIZE functions  you may need to pre-process the input enumerators first  here is the macro to do the job    define DEFINE ENUM WITH STRING CONVERSIONS FIRST ELEM r  data  elem                  BOOST PP TUPLE ELEM 0  elem     define DEFINE ENUM WITH STRING CONVERSIONS FIRST ELEM SEQ enumerators                BOOST PP SEQ SUBSEQ                                                                   BOOST PP TUPLE TO SEQ                                                                  BOOST PP SEQ FOR EACH                                                                DEFINE ENUM WITH STRING CONVERSIONS FIRST ELEM  0  enumerators                                                                                                  0                                                                                 BOOST PP SEQ SIZE enumerators     The macro DEFINE ENUM WITH STRING CONVERSIONS FIRST ELEM SEQ will only keep the first element in every TUPLE  and later convert to SEQ  now modify James  code  you will have the full power   My implementation maybe not the simplest one  so if you do not find any clean code  mine for your reference

User · Answer

I needed this to work in both directions AND I frequently embed my enums inside a containing class  and so I started with the solution by James McNellis way  way at the top of these answers  but I made this solution  Note also I prefer enum class rather than just enum  which complicates the answer somewhat    define X DEFINE ENUMERATION r  datatype  elem  case datatype  elem   return BOOST PP STRINGIZE elem       The data portion of the FOR EACH should be  variable type  value   define X DEFINE ENUMERATION2 r  dataseq  elem        if  BOOST PP SEQ ELEM 1  dataseq     BOOST PP STRINGIZE elem    return BOOST PP SEQ ELEM 0  dataseq   elem    define DEFINE ENUMERATION MASTER modifier  name  toFunctionName  enumerators           enum class name                                                                     Undefined                                                                       BOOST PP SEQ ENUM enumerators                                                                                                                                                                                                               modifier const char  ToString const name  amp  v                                                                                                                          switch  v                                                                                                                                                           BOOST PP SEQ FOR EACH                                                               X DEFINE ENUMERATION                                                            name                                                                            enumerators                                                                                                                                                 default  return   Unknown   BOOST PP STRINGIZE name                                                                                                                                                                                                                                                                     modifier const name toFunctionName const std  string  amp  value                                                                                                          BOOST PP SEQ FOR EACH                                                               X DEFINE ENUMERATION2                                                            name  value                                                                    enumerators                                                                                                                                                 return name  Undefined                                                          define DEFINE ENUMERATION name  toFunctionName  enumerators                        DEFINE ENUMERATION MASTER inline  name  toFunctionName  enumerators    define DEFINE ENUMERATION INSIDE CLASS name  toFunctionName  enumerators                        DEFINE ENUMERATION MASTER static  name  toFunctionName  enumerators    To use it inside a class  you could do something like this   class ComponentStatus   public          This is a simple bad  iffy  and good status  See other places for greater details         DEFINE ENUMERATION INSIDE CLASS Status  toStatus   RED  YELLOW  GREEN      And I wrote a CppUnit test  which demonstrates how to use it   void ComponentStatusTest  testSimple         ComponentStatus  Status value   ComponentStatus  Status  RED       const char   valueStr   ComponentStatus  ToString value        ComponentStatus  Status convertedValue   ComponentStatus  toStatus string valueStr         CPPUNIT ASSERT EQUAL MESSAGE  Incorrect conversion to a string     const char    RED   valueStr       CPPUNIT ASSERT EQUAL MESSAGE  Incorrect conversion back from a string    convertedValue  value      DEFINE ENUMERATION Status  toStatus   RED  YELLOW  GREEN    void ComponentStatusTest  testOutside         Status value   Status  RED       const char   valueStr   ToString value        Status convertedValue   toStatus string valueStr         CPPUNIT ASSERT EQUAL MESSAGE  Incorrect conversion to a string     const char    RED   valueStr       CPPUNIT ASSERT EQUAL MESSAGE  Incorrect conversion back from a string    convertedValue  value       You have to pick which macro to use  either DEFINE ENUMERATION or DEFINE ENUMERATION INSIDE CLASS  You ll see I used the latter when defining ComponentStatus  Status but I used the former when just defining Status  The difference is simple  Inside a class  I prefix the to from methods as  static  and if not in a class  I use  inline   Trivial differences  but necessary   Unfortunately  I don t think there s a clean way to avoid having to do this   const char   valueStr   ComponentStatus  ToString value     although you could manually create an inline method after your class definition that simply chains to the class method  something like   inline const char   toString const ComponentStatus  Status value    return ComponentStatus  ToString value

User · Answer

There are a lot of good answers here  but I thought some people might find mine useful   I like it because the interface that you use to define the macro is about as simple as it can get  It s also handy because you don t have to include any extra libraries - it all comes with C   and it doesn t even require a really late version   I pulled pieces from various places online so I can t take credit for all of it  but I think it s unique enough to warrant a new answer   First make a header file    call it EnumMacros h or something like that  and put this in it      Search and remove whitespace from both ends of the string static std  string TrimEnumString const std  string  amp s        std  string  const iterator it   s begin        while  it    s end    amp  amp  isspace  it     it          std  string  const reverse iterator rit   s rbegin        while  rit base      it  amp  amp  isspace  rit     rit          return std  string it  rit base        static void SplitEnumArgs const char  szArgs  std  string Array    int nMax        std  stringstream ss szArgs       std  string strSub      int nIdx   0      while  ss good    amp  amp   nIdx  lt  nMax             getline ss  strSub                Array nIdx    TrimEnumString strSub           nIdx                This will to define an enum that is wrapped in a namespace of the same name along with ToString    FromString    and COUNT  define DECLARE ENUM ename             namespace ename             enum ename     VA ARGS    COUNT              static std  string  Strings COUNT             static const char  ToString ename e                  if   Strings 0  empty      SplitEnumArgs    VA ARGS     Strings  COUNT                   return  Strings e  c str                          static ename FromString const std  string amp  strEnum                  if   Strings 0  empty      SplitEnumArgs    VA ARGS     Strings  COUNT                   for  int i   0  i  lt  COUNT  i      if   Strings i     strEnum    return  ename i                    return COUNT                        Then  in your main program you can do this      include  EnumMacros h  DECLARE ENUM OsType  Windows  Linux  Apple   void main         OsType  OsType MyOs   OSType  Apple      printf  The value of   s  is   d of  d n   OsType  ToString MyOs    int OsType  FromString  Apple    OsType  COUNT       Where the output would be    The value of  Apple  is  2 of 4  Enjoy

User · Answer

Use std  map lt OS type  std  string gt  and populate it with enum as key  and string representation as  values  then you can do these   printf  My OS is  s   enumMap myOS  c str     std  cout  lt  lt  enumMap myOS

User · Answer

The problem with C enums is that it s not a type of it s own  like it is in C    An enum in C is a way to map identifiers to integral values  Just that  That s why an enum value is interchangeable with integer values   As you guess correctly  a good way is to create a mapping between the enum value and a string  For example   char   OS type label            Linux        Apple        Windows

User · Answer

Here s the Old Skool method  used to be used extensively in gcc  using just the C pre-processor  Useful if you re generating discrete data structures but need to keep the order consistent between them   The entries in mylist tbl can of course be extended to something much more complex   test cpp   enum    undef XX  define XX name  ignore  name    include  mylist tbl    LAST ENUM     char   enum names         undef XX  define XX name  ignore   name    include  mylist tbl      LAST ENUM       And then mylist tbl         A   enum                           B   some associated value           A        B        XX  enum 1   100    XX  enum 2   100     XX  enum 3   200     XX  enum 4   900     XX  enum 5   500

User · Answer

I have combined the James   Howard s and   der s solutions and created a more generic implementation    int value and custom string representation can be optionally defined for each enum element  enum class  is used   The full code is written bellow  use  DEFINE ENUM CLASS WITH ToString METHOD  for defining an enum   online demo     include  lt boost preprocessor hpp gt   include  lt iostream gt      ADD PARENTHESES FOR EACH TUPLE IN SEQ implementation is taken from     http   lists boost org boost-users 2012 09 76055 php       This macro do the following     input           Element1   Element 1 string repr   2   Element2   Element3   Element 3 string repr      output            Element1   Element 1 string repr   2     Element2     Element3   Element 3 string repr     define HELPER1          VA ARGS     HELPER2  define HELPER2          VA ARGS     HELPER1  define HELPER1 END  define HELPER2 END  define ADD PARENTHESES FOR EACH TUPLE IN SEQ sequence  BOOST PP CAT HELPER1 sequence  END       CREATE ENUM ELEMENT IMPL works in the following way      if  elementTuple GetSize      4            GENERATE  elementTuple GetElement 0    elementTuple GetElement 2          else           GENERATE  elementTuple GetElement 0            Example 1          CREATE ENUM ELEMENT IMPL  Element1   Element 1 string repr   2          generates          Element1   2        Example 2          CREATE ENUM ELEMENT IMPL  Element2          generates          Element1   define CREATE ENUM ELEMENT IMPL elementTuple                                             BOOST PP IF BOOST PP EQUAL BOOST PP TUPLE SIZE elementTuple   4                               BOOST PP TUPLE ELEM 0  elementTuple    BOOST PP TUPLE ELEM 2  elementTuple                BOOST PP TUPLE ELEM 0  elementTuple                                                          we have to add a dummy element at the end of a tuple in order to make     BOOST PP TUPLE ELEM macro work in case an initial tuple has only one element     if we have a tuple  Element1   BOOST PP TUPLE ELEM 2   Element1   macro won t compile     It requires that a tuple with only one element looked like  Element1       Unfortunately I couldn t find a way to make this transformation  so    I just use BOOST PP TUPLE PUSH BACK macro to add a dummy element at the end    of a tuple  in this case the initial tuple will look like  Element1     what    makes it compatible with BOOST PP TUPLE ELEM macro  define CREATE ENUM ELEMENT r  data  elementTuple                                             CREATE ENUM ELEMENT IMPL BOOST PP TUPLE PUSH BACK elementTuple        define DEFINE CASE HAVING ONLY ENUM ELEMENT NAME enumName  element                                               case enumName  element   return BOOST PP STRINGIZE element    define DEFINE CASE HAVING STRING REPRESENTATION FOR ENUM ELEMENT enumName  element  stringRepresentation         case enumName  element   return stringRepresentation      GENERATE CASE FOR SWITCH macro generates case for switch operator     Algorithm of working is the following     if  elementTuple GetSize      1            DEFINE CASE HAVING ONLY ENUM ELEMENT NAME enumName  elementTuple GetElement 0         else           DEFINE CASE HAVING STRING REPRESENTATION FOR ENUM ELEMENT enumName  elementTuple GetElement 0   elementTuple GetElement 1               Example 1          GENERATE CASE FOR SWITCH    EnumName   Element1   Element 1 string repr   2       generates          case EnumName  Element1   return  Element 1 string repr         Example 2          GENERATE CASE FOR SWITCH    EnumName   Element2       generates          case EnumName  Element2   return  Element2    define GENERATE CASE FOR SWITCH r  enumName  elementTuple                                                                                                        BOOST PP IF BOOST PP EQUAL BOOST PP TUPLE SIZE elementTuple   1                                                                                                   DEFINE CASE HAVING ONLY ENUM ELEMENT NAME enumName  BOOST PP TUPLE ELEM 0  elementTuple                                                                       DEFINE CASE HAVING STRING REPRESENTATION FOR ENUM ELEMENT enumName  BOOST PP TUPLE ELEM 0  elementTuple   BOOST PP TUPLE ELEM 1  elementTuple                    DEFINE ENUM CLASS WITH ToString METHOD final macro witch do the job  define DEFINE ENUM CLASS WITH ToString METHOD enumName  enumElements             enum class enumName                                                                   BOOST PP SEQ FOR EACH                                                                 CREATE ENUM ELEMENT                                                               0                                                                                 ADD PARENTHESES FOR EACH TUPLE IN SEQ enumElements                                                                                                                                                                                            inline const char  ToString const enumName element                                        switch  element                                                                       BOOST PP SEQ FOR EACH                                                                 GENERATE CASE FOR SWITCH                                                          enumName                                                                          ADD PARENTHESES FOR EACH TUPLE IN SEQ enumElements                                                                                                              default  return   Unknown   BOOST PP STRINGIZE enumName                                                                                                    DEFINE ENUM CLASS WITH ToString METHOD Elements   Element1   Element2   string representation for Element2     Element3   Element3 string representation   1000   Element4   Element 4 string repr    Element5   Element5   1005   Element6   Element6     Element7       Generates the following          enum class Elements               Element1  Element2  Element3   1000  Element4  Element5   1005  Element6                     inline const char  ToString const Elements element                switch  element                    case Elements  Element1  return  Element1                   case Elements  Element2  return  string representation for Element2                    case Elements  Element3  return  Element3 string representation                   case Elements  Element4  return  Element 4 string repr                   case Elements  Element5  return  Element5                   case Elements  Element6  return  Element6                    case Elements  Element7  return  Element7                   default  return   Unknown    Elements                                int main         std  cout  lt  lt  ToString Elements  Element1   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element2   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element3   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element4   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element5   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element6   lt  lt  std  endl      std  cout  lt  lt  ToString Elements  Element7   lt  lt  std  endl       return 0

User · Answer

In c   like this   enum OS type Linux  Apple  Windows    std  string ToString  const OS type v       const std  map lt  OS type  std  string  gt  lut       boost  assign  map list of  Linux   Linux    Apple   Apple    Windows  Windows      std  map lt  OS type  std  string  gt   const iterator it   lut find  v      if   lut end      it       return it- gt second    return  NOT FOUND

[c++] How to convert an enum type variable to a string?

Examples related to c++

Examples related to c

Examples related to preprocessor

Examples related to ansi-c