Easy way to use variables of enum types as string in C

Question

Here s what I am trying to do     typedef enum   ONE  TWO  THREE   Numbers    I am trying to write a function that would do a switch case similar to the following    char num str 10   int process numbers str Numbers num      switch num        case ONE      case TWO      case THREE              strcpy num str  num     some way to get the symbolic constant name in here        break      default        return 0    no match   return 1      Instead of defining at every case  is there a way to set it using the enum variable like I am trying to do above

User · Answer

Define your enumeration like this  in say numbers h   ENUM BEGIN  Numbers       ENUM ONE       ENUM TWO       ENUM FOUR  ENUM END  Numbers       The macros are defined in a more fundamental  h file  say defs h    define ENUM BEGIN typ  enum typ    define ENUM nam  nam  define ENUM END typ         Now in one and only one  c file  redefine the ENUM macros and reinclude     the numbers h file to build a string table  undef ENUM BEGIN  undef ENUM  undef ENUM END  define ENUM BEGIN typ  const char   typ     name table         define ENUM nam   nam  define ENUM END typ      undef NUMBERS H INCLUDED      whatever you need to do to enable reinclusion  include  numbers h      Now you can do exactly what you want to do  with no retyping  and for any     number of enumerated types defined with the ENUM macro family     Your code follows  char num str 10   int process numbers str Numbers num      switch num        case ONE      case TWO      case THREE              strcpy num str  Numbers name table num       eg TWO - gt   TWO        break      default        return 0    no match   return 1        Sweet no   After being frustrated by this for years  I finally came up     with this solution for my most recent project and plan to reuse the idea     forever

User · Answer

KISS  You will be doing all sorts of other switch case things with your enums so why should printing be different  Forgetting a case in your print routine isn t a huge deal when you consider there are about 100 other places you can forget a case  Just compile -Wall  which will warn of non-exhaustive case matches  Don t use  default  because that will make the switch exhaustive and you wont get warnings  Instead  let the switch exit and deal with the default case like so     const char  myenum str myenum e        switch e        case ONE  return  one       case TWO  return  two             return  invalid

User · Answer

I thought that a solution like Boost Fusion one for adapting structs and classes would be nice  they even had it at some point  to use enums as a fusion sequence   So I made just some small macros to generate the code to print the enums  This is not perfect and has nothing to see with Boost Fusion generated boilerplate code  but can be used like the Boost Fusion macros  I want to really do generate the types needed by Boost Fusion to integrate in this infrastructure which allows to print names of struct members  but this will happen later  for now this is just macros     ifndef SWISSARMYKNIFE ENUMS ADAPT ENUM HPP  define SWISSARMYKNIFE ENUMS ADAPT ENUM HPP   include  lt swissarmyknife detail config hpp gt    include  lt string gt   include  lt ostream gt   include  lt boost preprocessor cat hpp gt   include  lt boost preprocessor stringize hpp gt   include  lt boost preprocessor seq for each hpp gt     define SWISSARMYKNIFE ADAPT ENUM EACH ENUMERATION ENTRY C                            R  unused  ENUMERATION ENTRY                                                      case ENUMERATION ENTRY                                                              return BOOST PP STRINGIZE ENUMERATION ENTRY                                     break                                                                                 brief Adapts ENUM to reflectable types         param ENUM TYPE To be adapted     param ENUMERATION SEQ Sequence of enum states      define SWISSARMYKNIFE ADAPT ENUM ENUM TYPE  ENUMERATION SEQ                          inline std  string to string const ENUM TYPE amp  enum value                            switch  enum value                                                                BOOST PP SEQ FOR EACH                                                                 SWISSARMYKNIFE ADAPT ENUM EACH ENUMERATION ENTRY C                                unused  ENUMERATION SEQ                                                         default                                                                             return BOOST PP STRINGIZE ENUM TYPE                                                                                                                                                                                                                                                                                               inline std  ostream amp  operator lt  lt  std  ostream amp  os  const ENUM TYPE amp  value            os  lt  lt  to string value                                                             return os                                                                           endif   The old answer below is pretty bad  please don t use that      Old answer   I ve been searching a way which solves this problem without changing too much the enums declaration syntax  I came to a solution which uses the preprocessor to retrieve a string from a stringified enum declaration   I m able to define non-sparse enums like this    SMART ENUM State       enum State           RUNNING          SLEEPING           FAULT           UNKNOWN          And I can interact with them in different ways      With a stringstream std  stringstream ss  ss  lt  lt  State  FAULT  std  string myEnumStr   ss str       Directly to stdout std  cout  lt  lt  State  FAULT  lt  lt  std  endl     to a string std  string myStr   State  to string State  FAULT      from a string State  State myEnumVal   State  from string State  FAULT     Based on the following definitions     define SMART ENUM enumTypeArg                                                             namespace enumTypeArg                                                                            VA ARGS                                                                                  std  ostream amp  operator lt  lt  std  ostream amp  os  const enumTypeArg amp  val                                  os  lt  lt  swissarmyknife  enums  to string    VA ARGS    val                                   return os                                                                                                                                                                                                                                                            std  string to string const enumTypeArg amp  val                                                       return swissarmyknife  enums  to string    VA ARGS    val                                                                                                                                                                                                            enumTypeArg from string const std  string  amp str                                                     return swissarmyknife  enums  from string lt enumTypeArg gt     VA ARGS    str                                                                                                                                                                                               namespace swissarmyknife   namespace enums        static inline std  string to string const std  string completeEnumDeclaration  size t enumVal  throw  std  runtime error            size t begin   completeEnumDeclaration find first of               size t end   completeEnumDeclaration find last of               const std  string identifiers   completeEnumDeclaration substr begin   1  end             size t count   0          size t found   0          do               found   identifiers find first of       found 1                if  enumVal    count                    std  string identifiersSubset   identifiers substr 0  found                   size t beginId   identifiersSubset find last of                        identifiersSubset   identifiersSubset substr beginId 1                   boost  algorithm  trim identifiersSubset                   return identifiersSubset                               count            while  found    std  string  npos            throw std  runtime error  The enum declaration provided doesn t contains this state                                                                  template  lt typename EnumType gt      static inline EnumType from string const std  string completeEnumDeclaration  const std  string  amp enumStr  throw  std  runtime error            size t begin   completeEnumDeclaration find first of               size t end   completeEnumDeclaration find last of               const std  string identifiers   completeEnumDeclaration substr begin   1  end             size t count   0          size t found   0          do               found   identifiers find first of       found 1                std  string identifiersSubset   identifiers substr 0  found               size t beginId   identifiersSubset find last of                    identifiersSubset   identifiersSubset substr beginId 1               boost  algorithm  trim identifiersSubset                if  identifiersSubset    enumStr                    return static cast lt EnumType gt  count                                count            while  found    std  string  npos            throw std  runtime error  No valid enum value for the provided string                                      When I ll need support for sparse enum and when I ll have more time I ll improve the to string and from string implementations with boost  xpressive  but this will costs in compilation time because of the important templating performed and the executable generated is likely to be really bigger  But this has the advantage that it will be more readable and maintanable than this ugly manual string manipulation code   D  Otherwise I always used boost  bimap to perform such mappings between enums value and string  but it has to be maintained manually

User · Answer

Making something both a C identifier and a string

User · Answer

C or C   does not provide this functionality  although I ve needed it often   The following code works  although it s best suited for non-sparse enums   typedef enum   ONE  TWO  THREE   Numbers  char  strNumbers       one   two   three    printf   Value for TWO is  s n  strNumbers TWO      By non-sparse  I mean not of the form  typedef enum   ONE  FOUR THOUSAND   4000   Numbers    since that has huge gaps in it   The advantage of this method is that it put the definitions of the enums and strings near each other  having a switch statement in a function spearates them  This means you re less likely to change one without the other

User · Answer

I have created a simple templated class streamable enum that uses stream operators  lt  lt  and  gt  gt  and is based on the std  map lt Enum  std  string gt      ifndef STREAMABLE ENUM HPP  define STREAMABLE ENUM HPP   include  lt iostream gt   include  lt string gt   include  lt map gt   template  lt typename E gt  class streamable enum   public      typedef typename std  map lt E  std  string gt  tostr map t      typedef typename std  map lt std  string  E gt  fromstr map t       streamable enum               streamable enum E val            Val  val              operator E             return Val              bool operator   const streamable enum lt E gt  amp  e            return this- gt Val     e Val              bool operator   const E amp  e            return this- gt Val     e             static const tostr map t amp  to string map             static tostr map t to str  get enum strings lt E gt              return to str              static const fromstr map t amp  from string map             static fromstr map t from str  reverse map to string map              return from str         private      E Val        static fromstr map t reverse map const tostr map t amp  eToS            fromstr map t sToE          for  auto pr   eToS                sToE emplace pr second  pr first                     return sToE            template  lt typename E gt  streamable enum lt E gt  stream enum E e        return streamable enum lt E gt  e      template  lt typename E gt  typename streamable enum lt E gt   tostr map t get enum strings             todo throw an appropriate exception or display compile error warning     return        template  lt typename E gt  std  ostream amp  operator lt  lt  std  ostream amp  os  streamable enum lt E gt  e        auto amp  mp   streamable enum lt E gt   to string map        auto res   mp find e       if  res    mp end              os  lt  lt  res- gt second        else           os setstate std  ios base  failbit             return os     template  lt typename E gt  std  istream amp  operator gt  gt  std  istream amp  is  streamable enum lt E gt  amp  e        std  string str      is  gt  gt  str      if  str empty              is setstate std  ios base  failbit             auto amp  mp   streamable enum lt E gt   from string map        auto res   mp find str       if  res    mp end              e   res- gt second        else           is setstate std  ios base  failbit             return is      endif   Usage    include  streamable enum hpp   using std  cout  using std  cin  using std  endl   enum Animal       CAT      DOG      TIGER      RABBIT     template  lt  gt  streamable enum lt Animal gt   tostr map t get enum strings lt Animal gt          return             CAT   Cat              DOG   Dog               TIGER   Tiger               RABBIT   Rabbit              int main int argc  char  argv           cout  lt  lt   What animal do you want to buy  Our offering    lt  lt  endl      for  auto pr   streamable enum lt Animal gt   to string map                  Use from string map   and pr first instead         cout  lt  lt       lt  lt  pr second  lt  lt  endl                                   to have them sorted in alphabetical order           streamable enum lt Animal gt  anim      cin  gt  gt  anim      if   cin            cout  lt  lt   We don t have such animal here    lt  lt  endl        else if  anim    Animal  TIGER            cout  lt  lt  stream enum Animal  TIGER   lt  lt    was a joke      lt  lt  endl        else           cout  lt  lt   Here you are    lt  lt  endl             return 0

User · Answer

Try Converting C   enums to strings  The comments have improvements that solve the problem when enum items have arbitrary values

User · Answer

By merging some of the techniques over here I came up with the simplest form    define MACROSTR k   k   define X NUMBERS          X kZero             X kOne              X kTwo              X kThree            X kFour             X kMax      enum    define X Enum        Enum      X NUMBERS  undef X   kConst   static char  kConstStr        define X String  MACROSTR String       X NUMBERS  undef X     int main void        int k      printf  Hello World  n n         for  k   0  k  lt  kMax  k                  printf   s n   kConstStr k               return 0

User · Answer

Check out the ideas at Mu Dynamics Research Labs - Blog Archive   I found this earlier this year - I forget the exact context where I came across it - and have adapted it into this code   We can debate the merits of adding an E at the front  it is applicable to the specific problem addressed  but not part of a general solution   I stashed this away in my  vignettes  folder - where I keep interesting scraps of code in case I want them later   I m embarrassed to say that I didn t keep a note of where this idea came from at the time   Header  paste1 h         File             RCSfile  paste1 h v       Version          Revision  1 1       Last changed     Date  2008 05 17 21 38 05       Purpose         Automated Token Pasting      ifndef JLSS ID PASTE H  define JLSS ID PASTE H        Common case when someone just includes this file   In this case     they just get the various E  tokens as good old enums       if  defined ETYPE   define ETYPE val  desc  E  val   define ETYPE ENUM enum    endif    ETYPE        ETYPE PERM    Operation not permitted      ETYPE NOENT   No such file or directory      ETYPE SRCH    No such process      ETYPE INTR    Interrupted system call      ETYPE IO      I O error      ETYPE NXIO    No such device or address      ETYPE 2BIG    Arg list too long          Close up the enum block in the common case of someone including    this file       if defined ETYPE ENUM   undef ETYPE ENUM  undef ETYPE ETYPE MAX     endif    ETYPE ENUM      endif    JLSS ID PASTE H      Example source          File             RCSfile  paste1 c v       Version          Revision  1 2       Last changed     Date  2008 06 24 01 03 38       Purpose         Automated Token Pasting      include  paste1 h   static const char  sys errlist internal        undef JLSS ID PASTE H  define ETYPE val  desc  desc   include  paste1 h      0  undef ETYPE     static const char  xerror int err        if  err  gt   ETYPE MAX    err  lt   0          return  Unknown error       return sys errlist internal err      static const char errlist mnemonics        undef JLSS ID PASTE H  define ETYPE val  desc   E    val     E   val   include  paste1 h   undef ETYPE      include  lt stdio h gt   int main void        int i       for  i   0  i  lt  ETYPE MAX  i                  printf   d   -6s   s n   i  errlist mnemonics i   xerror i              return 0       Not necessarily the world s cleanest use of the C pre-processor - but it does prevent writing the material out multiple times

User · Answer

I know you have a couple good solid answers  but do you know about the   operator in the C preprocessor   It lets you do this    define MACROSTR k   k  typedef enum       kZero      kOne      kTwo      kThree   kConst   static char  kConstStr           MACROSTR kZero       MACROSTR kOne       MACROSTR kTwo       MACROSTR kThree      static void kConstPrinter kConst k        printf   s   kConstStr k

User · Answer

The technique from Making something both a C identifier and a string  can be used here   As usual with such preprocessor stuff  writing and understanding the preprocessor part can be hard  and includes passing macros to other macros and involves using   and    operators  but using it is real easy  I find this style very useful for long enums  where maintaining the same list twice can be really troublesome   Factory code - typed only once  usually hidden in the header   enumFactory h      expansion macro for enum value definition  define ENUM VALUE name assign  name assign      expansion macro for enum to string conversion  define ENUM CASE name assign  case name  return  name      expansion macro for string to enum conversion  define ENUM STRCMP name assign  if   strcmp str  name   return name       declare the access function and define enum values  define DECLARE ENUM EnumType ENUM DEF      enum EnumType         ENUM DEF ENUM VALUE             const char  GetString EnumType dummy       EnumType Get  EnumType  Value const char  string          define the access function names  define DEFINE ENUM EnumType ENUM DEF      const char  GetString EnumType value              switch value                  ENUM DEF ENUM CASE          default  return        handle input error                      EnumType Get  EnumType  Value const char  str              ENUM DEF ENUM STRCMP        return  EnumType 0     handle input error              Factory used  someEnum h    include  enumFactory h   define SOME ENUM XX        XX FirstValue         XX SecondValue         XX SomeOtherValue  50        XX OneMoreValue  100     DECLARE ENUM SomeEnum SOME ENUM    someEnum cpp    include  someEnum h  DEFINE ENUM SomeEnum SOME ENUM    The technique can be easily extended so that XX macros accepts more arguments  and you can also have prepared more macros to substitute for XX for different needs  similar to the three I have provided in this sample   Comparison to X-Macros using  include    define    undef  While this is similar to X-Macros others have mentioned  I think this solution is more elegant in that it does not require  undefing anything  which allows you to hide more of the complicated stuff is in the factory the header file - the header file  is something you are not touching at all when you need to define a new enum  therefore new enum definition is a lot shorter and cleaner

User · Answer

If you are using gcc  it s possible to use   const char   enum to string map      enum1   string1    enum2   string2      Then just call for instance  enum to string map enum1

User · Answer

Here is a solution using macros with the following features    only write each value of the enum once  so there are no double lists to maintain don t keep the enum values in a separate file that is later  included  so I can write it wherever I want don t replace the enum itself  I still want to have the enum type defined  but in addition to it I want to be able to map every enum name to the corresponding string  to not affect legacy code  the searching should be fast  so preferably no switch-case  for those huge enums   https   stackoverflow com a 20134475 1812866

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

There is definitely a way to do this -- use X   macros  These macros use the C preprocessor to construct enums  arrays and code blocks from a list of source data  You only need to add new items to the  define containing the X   macro  The switch statement would expand automatically   Your example can be written as follows       Source data -- Enum  String   define X NUMBERS       X ONE     one         X TWO     two         X THREE   three              Use preprocessor to create the Enum  typedef enum      define X Enum  String        Enum     X NUMBERS    undef X    Numbers             Use Preprocessor to expand data into switch statement cases  switch num       define X Enum  String         case Enum   strcpy num str  String   break   X NUMBERS   undef X       default  return 0  break      return 1    There are more efficient ways  i e  using X Macros to create an string array and enum index   but this is the simplest demo

User · Answer

Because I prefer not to use macros for all the usual reasons  I used a more limited macro solution that has the advantage of keeping the enum declaration macro free  Disadvantages include having to copy paste the macro defintion for each enum  and having to explicitly add a macro invocation when adding values to the enum   std  ostream amp  operator lt  lt  std  ostream amp  os  provenance wrapper  CaptureState cs     define HANDLE x  case x  os  lt  lt   x  break      switch  cs        HANDLE CaptureState  UNUSED      HANDLE CaptureState  ACTIVE      HANDLE CaptureState  CLOSED            return os   undef HANDLE

User · Answer

If the enum index is 0-based  you can put the names in an array of char   and index them with the enum value

User · Answer

There s no built-in solution  The easiest way is with an array of char  where the enum s int value indexes to a string containing the descriptive name of that enum  If you have a sparse enum  one that doesn t start at 0 or has gaps in the numbering  where some of the int mappings are high enough to make an array-based mapping impractical then you could use a hash table instead

User · Answer

The technique from Making something both a C identifier and a string  can be used here   As usual with such preprocessor stuff  writing and understanding the preprocessor part can be hard  and includes passing macros to other macros and involves using   and    operators  but using it is real easy  I find this style very useful for long enums  where maintaining the same list twice can be really troublesome   Factory code - typed only once  usually hidden in the header   enumFactory h      expansion macro for enum value definition  define ENUM VALUE name assign  name assign      expansion macro for enum to string conversion  define ENUM CASE name assign  case name  return  name      expansion macro for string to enum conversion  define ENUM STRCMP name assign  if   strcmp str  name   return name       declare the access function and define enum values  define DECLARE ENUM EnumType ENUM DEF      enum EnumType         ENUM DEF ENUM VALUE             const char  GetString EnumType dummy       EnumType Get  EnumType  Value const char  string          define the access function names  define DEFINE ENUM EnumType ENUM DEF      const char  GetString EnumType value              switch value                  ENUM DEF ENUM CASE          default  return        handle input error                      EnumType Get  EnumType  Value const char  str              ENUM DEF ENUM STRCMP        return  EnumType 0     handle input error              Factory used  someEnum h    include  enumFactory h   define SOME ENUM XX        XX FirstValue         XX SecondValue         XX SomeOtherValue  50        XX OneMoreValue  100     DECLARE ENUM SomeEnum SOME ENUM    someEnum cpp    include  someEnum h  DEFINE ENUM SomeEnum SOME ENUM    The technique can be easily extended so that XX macros accepts more arguments  and you can also have prepared more macros to substitute for XX for different needs  similar to the three I have provided in this sample   Comparison to X-Macros using  include    define    undef  While this is similar to X-Macros others have mentioned  I think this solution is more elegant in that it does not require  undefing anything  which allows you to hide more of the complicated stuff is in the factory the header file - the header file  is something you are not touching at all when you need to define a new enum  therefore new enum definition is a lot shorter and cleaner

User · Answer

The use of boost  preprocessor makes possible an elegant solution like the following   Step 1  include the header file    include  EnumUtilities h    Step 2  declare the enumeration object with the following syntax   MakeEnum  TestData            x            y            z                Step 3  use your data   Getting the number of elements   td  cout  lt  lt   Number of Elements     lt  lt  TestDataCount  lt  lt  std  endl    Getting the associated string   std  cout  lt  lt   Value of    lt  lt  TestData2String x   lt  lt    is    lt  lt  x  lt  lt  std  endl  std  cout  lt  lt   Value of    lt  lt  TestData2String y   lt  lt    is    lt  lt  y  lt  lt  std  endl  std  cout  lt  lt   Value of    lt  lt  TestData2String z   lt  lt    is    lt  lt  z  lt  lt  std  endl    Getting the enum value from the associated string   std  cout  lt  lt   Value of x is    lt  lt  TestData2Enum  x    lt  lt  std  endl  std  cout  lt  lt   Value of y is    lt  lt  TestData2Enum  y    lt  lt  std  endl  std  cout  lt  lt   Value of z is    lt  lt  TestData2Enum  z    lt  lt  std  endl    This looks clean and compact  with no extra files to include  The code I wrote within EnumUtilities h is the following    include  lt boost preprocessor seq for each hpp gt   include  lt string gt    define REALLY MAKE STRING x   x  define MAKE STRING x  REALLY MAKE STRING x   define MACRO1 r  data  elem  elem   define MACRO1 STRING r  data  elem     case elem  return REALLY MAKE STRING elem    define MACRO1 ENUM r  data  elem       if  REALLY MAKE STRING elem     eStrEl  return elem     define MakeEnum eName  SEQ        enum eName   BOOST PP SEQ FOR EACH MACRO1    SEQ        last   eName   enum         const int eName  Count   BOOST PP SEQ SIZE SEQ         static std  string eName  2String const enum eName eel                    switch  eel                        BOOST PP SEQ FOR EACH MACRO1 STRING    SEQ            default  return  Unknown enumerator value                                static enum eName eName  2Enum const std  string eStrEl                    BOOST PP SEQ FOR EACH MACRO1 ENUM    SEQ            return  enum eName 0             There are some limitation  i e  the ones of boost  preprocessor  In this case  the list of constants cannot be larger than 64 elements   Following the same logic  you could also think to create sparse enum    define EnumName Tuple                  BOOST PP TUPLE ELEM 2  0  Tuple   define EnumValue Tuple                 BOOST PP TUPLE ELEM 2  1  Tuple   define MACRO2 r  data  elem            EnumName elem  EnumValue elem    define MACRO2 STRING r  data  elem     case EnumName elem   return BOOST PP STRINGIZE EnumName elem      define MakeEnumEx eName  SEQ        enum eName         BOOST PP SEQ FOR EACH MACRO2     SEQ        last   eName   enum          const int eName  Count   BOOST PP SEQ SIZE SEQ         static std  string eName  2String const enum eName eel                    switch  eel                        BOOST PP SEQ FOR EACH MACRO2 STRING     SEQ            default  return  Unknown enumerator value                              In this case  the syntax is   MakeEnumEx TestEnum               x                 y  1000                z                    Usage is similar as above  minus the eName  2Enum function  that you could try to extrapolate from the previous syntax    I tested it on mac and linux  but be aware that boost  preprocessor may not be fully portable

[c] Easy way to use variables of enum types as string in C?

Examples related to c

Examples related to enums

Examples related to c-preprocessor