enum to string in modern C 11 C 14 C 17 and future C 20

Question

Contrary to all other similar questions  this question is about using the new C   features   2008 c Is there a simple way to convert C   enum to string  2008 c Easy way to use variables of enum types as string in C  2008 c   How to easily map c   enums to strings 2008 c   Making something both a C identifier and a string  2008 c   Is there a simple script to convert C   enum to string  2009 c   How to use enums as flags in C    2011 c   How to convert an enum type variable to a string  2011 c   Enum to String C   2011 c   How to convert an enum type variable to a string  2012 c How to convert enum names to string in c 2013 c Stringifying an conditionally compiled enum in C  After reading many answers  I did not yet find any   Elegant way using C  11  C  14 or C  17 new features Or something ready-to-use in Boost Else something planned for C  20  Example An example is often better than a long explanation  You can compile and run this snippet on Coliru   Another former example is also available   include  lt map gt   include  lt iostream gt   struct MyClass       enum class MyEnum   char           AAA   -8          BBB    8           CCC   AAA   BBB               Replace magic   by some faster compile-time generated code     you re allowed to replace the return type with std  string    if that s easier for you  const char  magic  MyClass  MyEnum e        const std  map lt MyClass  MyEnum const char  gt  MyEnumStrings             MyClass  MyEnum  AAA   quot MyClass  MyEnum  AAA quot               MyClass  MyEnum  BBB   quot MyClass  MyEnum  BBB quot               MyClass  MyEnum  CCC   quot MyClass  MyEnum  CCC quot               auto   it    MyEnumStrings find e       return it    MyEnumStrings end      quot Out of range quot    it- gt second     int main        std  cout  lt  lt  magic MyClass  MyEnum  AAA   lt  lt   n      std  cout  lt  lt  magic MyClass  MyEnum  BBB   lt  lt   n      std  cout  lt  lt  magic MyClass  MyEnum  CCC   lt  lt   n      Constraints  Please no valueless duplication of other answers or basic link  Please avoid bloat macro-based answer  or try to reduce the  define overhead as minimum as possible  Please no manual enum - gt  string mapping   Nice to have  Support enum values starting from a number different from zero Support negative enum values Support fragmented enum values Support class enum  C  11  Support class enum    lt type gt  having any allowed  lt type gt   C  11  Compile-time  not run-time  conversions to a string  or at least fast execution at run-time  e g  std  map is not a great idea     constexpr  C  11  then relaxed in C  14 17 20  noexcept  C  11  C  17 C  20 friendly snippet  One possible idea could be using the C   compiler capabilities to generate C   code at compilation-time using meta-programming tricks based on variadic template class and constexpr functions

User · Answer

Just generate your enums  Writing a generator for that purpose is about five minutes  work   Generator code in java and python  super easy to port to any language you like  including C     Also super easy to extend by whatever functionality you want   example input   First   5 Second Third   7 Fourth Fifth 11   generated header    include  lt iosfwd gt   enum class Hallo       First   5      Second   6      Third   7      Fourth   8      Fifth   11     std  ostream  amp  operator  lt  lt   std  ostream  amp   const Hallo amp      generated cpp file   include  lt ostream gt    include  Hallo h   std  ostream  amp  operator  lt  lt   std  ostream  amp out  const Hallo amp value        switch value            case Hallo  First          out  lt  lt   First           break      case Hallo  Second          out  lt  lt   Second           break      case Hallo  Third          out  lt  lt   Third           break      case Hallo  Fourth          out  lt  lt   Fourth           break      case Hallo  Fifth          out  lt  lt   Fifth           break      default          out  lt  lt    lt unknown gt               return out      And the generator  in a very terse form as a template for porting and extension  This example code really tries to avoid overwriting any files but still use it at your own risk   package cppgen   import java io BufferedReader  import java io File  import java io FileInputStream  import java io FileOutputStream  import java io InputStreamReader  import java io OutputStreamWriter  import java io PrintWriter  import java nio charset Charset  import java util LinkedHashMap  import java util Map  import java util Map Entry  import java util regex Matcher  import java util regex Pattern   public class EnumGenerator       static void fail String message                System err println message           System exit 1              static void run String   args      throws Exception               Pattern pattern   Pattern compile    s    w    s       s    d      s    Pattern UNICODE CHARACTER CLASS           Charset charset   Charset forName  UTF8            String tab                    if  args length    3                        fail  Required arguments   lt enum name gt   lt input file gt   lt output dir gt                        String enumName   args 0            File inputFile   new File args 1             if  inputFile isFile      false                        fail  Not a file       inputFile getCanonicalPath                              File outputDir   new File args 2             if  outputDir isDirectory      false                        fail  Not a directory       outputDir getCanonicalPath                              File headerFile   new File outputDir  enumName     h            File codeFile   new File outputDir  enumName     cpp             for  File file   new File     headerFile  codeFile                          if  file exists                                  fail  Will not overwrite file      file getCanonicalPath                                            int nextValue   0           Map lt String  Integer gt  fields   new LinkedHashMap lt  gt              try                       BufferedReader reader   new BufferedReader new InputStreamReader new FileInputStream inputFile   charset                                    while  true                                String line   reader readLine                     if  line    null                                        break                                     if  line trim   length      0                                        continue                                     Matcher matcher   pattern matcher line                    if  matcher matches      false                                        fail  Syntax error       line                                            String fieldName   matcher group 1                    if  fields containsKey fieldName                                         fail  Double fiend name      fieldName                                      String valueString   matcher group 2                    if  valueString    null                                        int value   Integer parseInt valueString                        if  value  lt  nextValue                                                fail  Not a monotonous progression from     nextValue     to     value     for enum field     fieldName                                              nextValue   value                                     fields put fieldName  nextValue                      nextValue                                   try                       PrintWriter headerWriter   new PrintWriter new OutputStreamWriter new FileOutputStream headerFile   charset                PrintWriter codeWriter   new PrintWriter new OutputStreamWriter new FileOutputStream codeFile   charset                                    headerWriter println                headerWriter println   include  lt iosfwd gt                 headerWriter println                headerWriter println  enum class     enumName               headerWriter println                   boolean first   true              for  Entry lt String  Integer gt  entry   fields entrySet                                  if  first    false                                        headerWriter println                                          headerWriter print tab   entry getKey             entry getValue                      first   false                            if  first    false                                headerWriter println                              headerWriter println                    headerWriter println                headerWriter println  std  ostream  amp  operator  lt  lt   std  ostream  amp   const     enumName     amp                   headerWriter println                 codeWriter println                codeWriter println   include  lt ostream gt                 codeWriter println                codeWriter println   include       enumName     h                  codeWriter println                codeWriter println  std  ostream  amp  operator  lt  lt   std  ostream  amp out  const     enumName     amp value                 codeWriter println                   codeWriter println tab    switch value                 codeWriter println tab                     first   true              for  Entry lt String  Integer gt  entry   fields entrySet                                  codeWriter println tab    case     enumName          entry getKey                           codeWriter println tab   tab    out  lt  lt        entry getKey                             codeWriter println tab   tab    break                      first   false                            codeWriter println tab    default                 codeWriter println tab   tab    out  lt  lt     lt unknown gt                    codeWriter println tab                     codeWriter println                codeWriter println tab    return out                 codeWriter println                   codeWriter println                         public static void main String   args                try                       run args                     catch Exception exc                        exc printStackTrace                System exit 1                       And a port to Python 3 5 because different enough to be potentially helpful  import re import collections import sys import io import os  def fail  args       print  args      exit 1   pattern   re compile r  s   w   s      s   d     s    tab           if len sys argv     4      n 0     for arg in sys argv          print  arg   n       arg         sys argv n           n    1     fail  Required arguments   lt enum name gt   lt input file gt   lt output dir gt     enumName   sys argv 1   inputFile   sys argv 2   if not os path isfile inputFile       fail  Not a file       os path abspath inputFile          outputDir   sys argv 3   if not os path isdir outputDir       fail  Not a directory       os path abspath outputDir          headerFile   os path join outputDir  enumName     h   codeFile   os path join outputDir  enumName     cpp    for file in   headerFile  codeFile        if os path exists file           fail  Will not overwrite file      os path abspath file          nextValue   0  fields   collections OrderedDict    for line in open inputFile   r        line   line strip        if len line     0          continue      match   pattern match line       if match    None          fail  Syntax error       line             fieldName   match group 1       if fieldName in fields          fail  Double field name      fieldName       valueString   match group 2       if valueString    None          value   int valueString           if value  lt  nextValue              fail  Not a monotonous progression from     nextValue     to     value     for enum field     fieldName           nextValue   value      fields fieldName    nextValue      nextValue    1  headerWriter   open headerFile   w   codeWriter   open codeFile   w    try      headerWriter write   n       headerWriter write   include  lt iosfwd gt  n       headerWriter write   n       headerWriter write  enum class     enumName     n       headerWriter write    n       first   True     for fieldName  fieldValue in fields items            if not first              headerWriter write    n            headerWriter write tab   fieldName           str fieldValue            first   False     if not first          headerWriter write   n       headerWriter write     n       headerWriter write   n       headerWriter write  std  ostream  amp  operator  lt  lt   std  ostream  amp   const     enumName     amp    n       headerWriter write   n        codeWriter write   n       codeWriter write   include  lt ostream gt  n       codeWriter write   n       codeWriter write   include       enumName     h   n       codeWriter write   n       codeWriter write  std  ostream  amp  operator  lt  lt   std  ostream  amp out  const     enumName     amp value  n       codeWriter write    n       codeWriter write tab    switch value  n       codeWriter write tab      n       for fieldName in fields keys            codeWriter write tab    case     enumName          fieldName      n           codeWriter write tab   tab    out  lt  lt        fieldName        n           codeWriter write tab   tab    break  n       codeWriter write tab    default  n       codeWriter write tab   tab    out  lt  lt     lt unknown gt     n       codeWriter write tab      n       codeWriter write   n       codeWriter write tab    return out  n       codeWriter write    n       codeWriter write   n   finally      headerWriter close       codeWriter close

User · Answer

my solution is without macro usage   advantages    you see exactly what you do access is with hash maps  so good for many valued enums no need to consider order or non-consecutive values both enum to string and string to enum translation  while added enum value must be added in one additional place only   disadvantages    you need to replicate all the enums values as text  access in hash map must consider string case maintenance if adding values is painful - must add in both enum and direct translate map   so    until the day that C   implements the C  Enum Parse functionality  I will be stuck with this                include  lt unordered map gt               enum class Language               unknown                   Chinese                   English                   French                   German                    etc etc                             class Enumerations                           public                  static void fnInit void                    static std  unordered map  lt std  wstring  Language gt  m Language                  static std  unordered map  lt Language  std  wstring gt  m invLanguage               private                  static void fnClear                    static void fnSetValues void                   static void fnInvertValues void                    static bool m init done                              std  unordered map  lt std  wstring  Language gt  Enumerations  m Language   std  unordered map  lt std  wstring  Language gt                 std  unordered map  lt Language  std  wstring gt  Enumerations  m invLanguage   std  unordered map  lt Language  std  wstring gt                  void Enumerations  fnInit                                 fnClear                    fnSetValues                    fnInvertValues                               void Enumerations  fnClear                                 m Language clear                    m invLanguage clear                               void Enumerations  fnSetValues void                                   m Language L unknown     Language  unknown                  m Language L Chinese     Language  Chinese                  m Language L English     Language  English                  m Language L French     Language  French                  m Language L German     Language  German                     and more etc etc                            void Enumerations  fnInvertValues void                                for  auto it   m Language begin    it    m Language end    it                                          m invLanguage it- gt second    it- gt first                                                  usage -               Language aLanguage   Language  English                wstring sLanguage   Enumerations  m invLanguage aLanguage                  wstring sLanguage   L French                  Language aLanguage   Enumerations  m Language sLanguage

User · Answer

For C  17 C  20  you will be interested in the work of the Reflection Study Group  SG7   There is a parallel series of papers covering wording  P0194  and rationale  design and evolution  P0385    Links resolve to the latest paper in each series    As of P0194r2  2016-10-15   the syntax would use the proposed reflexpr keyword   meta  get base name v lt    meta  get element m lt      meta  get enumerators m lt reflexpr MyEnum  gt       0 gt     gt    For example  adapted from Matus Choclik s reflexpr branch of clang     include  lt reflexpr gt   include  lt iostream gt   enum MyEnum   AAA   1  BBB  CCC   99     int main       auto name of MyEnum 0        std  meta  get base name v lt        std  meta  get element m lt          std  meta  get enumerators m lt reflexpr MyEnum  gt           0 gt       gt         prints  AAA    std  cout  lt  lt  name of MyEnum 0  lt  lt  std  endl      Static reflection failed to make it into C  17  rather  into the probably-final draft presented at the November 2016 standards meeting in Issaquah  but there is confidence that it will make it into C  20  from Herb Sutter s trip report      In particular  the Reflection study group reviewed the latest merged static reflection proposal and found it ready to enter the main Evolution groups at our next meeting to start considering the unified static reflection proposal for a TS or for the next standard

User · Answer

I have been frustrated by this problem for a long time too  along with the problem of getting a type converted to string in a proper way  However  for the last problem  I was surprised by the solution explained in Is it possible to print a variable  39 s type in standard C     using the idea from Can I obtain C   type names in a constexpr way   Using this technique  an analogous function can be constructed for getting an enum value as string    include  lt iostream gt  using namespace std   class static string       const char  const p       const std  size t sz    public      typedef const char  const iterator       template  lt std  size t N gt      constexpr static string const char  amp a  N   noexcept           p  a            sz  N - 1              constexpr static string const char  p  std  size t N  noexcept           p  p            sz  N              constexpr const char  data   const noexcept   return p         constexpr std  size t size   const noexcept   return sz          constexpr const iterator begin   const noexcept   return p         constexpr const iterator end     const noexcept   return p    sz          constexpr char operator   std  size t n  const               return n  lt  sz    p  n    throw std  out of range  static string              inline std  ostream amp  operator lt  lt  std  ostream amp  os  static string const amp  s        return os write s data    s size             brief Get the name of a type template  lt class T gt  static string typeName      ifdef   clang       static string p     PRETTY FUNCTION        return static string p data     30  p size   - 30 - 1    elif defined  MSC VER      static string p     FUNCSIG        return static string p data     37  p size   - 37 - 7    endif     namespace details       template  lt class Enum gt      struct EnumWrapper               template  lt  Enum enu  gt          static static string name              ifdef   clang               static string p     PRETTY FUNCTION                static string enumType   typeName lt Enum gt                 return static string p data     73   enumType size    p size   - 73 - enumType size   - 1    elif defined  MSC VER              static string p     FUNCSIG                static string enumType   typeName lt Enum gt                 return static string p data     57   enumType size    p size   - 57 - enumType size   - 7    endif                          brief Get the name of an enum value template  lt typename Enum  Enum enu gt  static string enumName         return details  EnumWrapper lt Enum gt   template name lt enu gt        enum class Color       Blue   0      Yellow   1      int main          std  cout  lt  lt       lt  lt  typeName lt Color gt     lt  lt        lt  lt  std  endl      std  cout  lt  lt       lt  lt  enumName lt Color  Color  Blue gt     lt  lt        lt  lt  std  endl      return 0      The code above has only been tested on Clang  see https   ideone com je5Quv  and VS2015  but should be adaptable to other compilers by fiddling a bit with the integer constants  Of course  it still uses macros under the hood  but at least one doesn t need access to the enum implementation

User · Answer

Solutions using enum within class struct  struct defaults with public members  and overloaded operators   struct Color       enum Enum   RED  GREEN  BLUE        Enum e       Color          Color Enum e    e e          Color operator  Enum o    e   o  return  this        Color operator  Color o    e   o e  return  this        bool operator   Enum o    return e    o        bool operator   Color o    return e    o e        operator Enum   const   return e         std  string toString   const               switch  e                    case Color  RED              return  red           case Color  GREEN              return  green           case Color  BLUE              return  blue           default              return  unknown                        From the outside it looks nearly exactly like a class enum   Color red  red   Color  RED  Color blue   Color  BLUE   cout  lt  lt  red toString    lt  lt       lt  lt  Color  GREEN  lt  lt       lt  lt  blue  lt  lt  endl    This will output  red 1 2   You could possibly overload  lt  lt  to make blue output a string  although it might cause ambiguity so not possible   but it wouldn t work with Color  GREEN since it doesn t automatically convert to Color   The purpose of having an implicit convert to Enum  which implicitly converts to int or type given  is to be able to do   Color color  switch  color        This works  but it also means that this work too   int i   color    With an enum class it wouldn t compile  You ought to be careful if you overload two functions taking the enum and an integer  or remove the implicit conversion     Another solution would involve using an actual enum class and static members   struct Color       enum class Enum   RED  GREEN  BLUE        static const Enum RED   Enum  RED  GREEN   Enum  GREEN  BLUE   Enum  BLUE         same as previous         It possibly takes more space  and is longer to make  but causes a compile error for implicit int conversions  I d use this one because of that   There s surely overhead with this though  but I think it s just simpler and looks better than other code I ve seen  There s also potential for adding functionality  which could all be scoped within the class   Edit  this works and most can be compiled before execution   class Color   public      enum class Enum   RED  GREEN  BLUE        static const Enum RED   Enum  RED  GREEN   Enum  GREEN  BLUE   Enum  BLUE       constexpr Color     e Enum  RED         constexpr Color Enum e    e e          constexpr bool operator   Enum o  const   return e    o        constexpr bool operator   Color o  const   return e    o e        constexpr operator Enum   const   return e         Color amp  operator  Enum o    const cast lt Enum gt  this- gt e    o  return  this        Color amp  operator  Color o    const cast lt Enum gt  this- gt e    o e  return  this         std  string toString   const               switch  e                    case Enum  RED              return  red           case Enum  GREEN              return  green           case Enum  BLUE              return  blue           default              return  unknown                   private      const Enum e

User · Answer

I am not sure if this approach is already covered in one of the other answers  actually it is  see below   I encountered the problem many times and didnt find a solution that did not use obfuscated macros or third party libraries  Hence I decided to write my own obfuscated macro version    What I want to enable is the equivalent of  enum class test1   ONE  TWO   13  SIX     std  string toString const test1 amp  e           int main         test1 x      std  cout  lt  lt  toString x   lt  lt    n       std  cout  lt  lt  toString test1  TWO   lt  lt    n       std  cout  lt  lt  static cast lt std  underlying type lt test1 gt   type gt  test1  TWO   lt  lt    n         std  cout  lt  lt  toString 123     invalid     which should print  ONE TWO 13   I am not a fan of macros  However  unless c   natively supports converting enums to strings one has to use some sort of code generation and or macros  and I doubt this will happen too soon   I am using a X-macro       x enum h  include  lt string gt   include  lt map gt   include  lt type traits gt   define x begin enum class x name    define x val X  X  define x value X Y  X   Y  define x end    x enum def  undef x begin  undef x val  undef x value  undef x end   define x begin inline std  string toString const x name amp  e                      static std  map lt x name std  string gt  names       define x val X         x name  X    X    define x value X Y     x name  X    X    define x end    return names e     x enum def  undef x begin  undef x val  undef x value  undef x end  undef x name  undef x enum def   Most of it is defining and undefining symbols that the user will pass as parameter to the X-marco via an include  The usage is like this   define x name test1  define x enum def x begin x val ONE                                 x value TWO 13                                 x val SIX                       x end  include  x enum h    Live Demo  Note that I didnt include choosing the underlying type yet  I didnt need it so far  but it should be straight forward to modify to code to enable that    Only after writing this I realized that it is rather similar to eferions answer  Maybe I read it before and maybe it was the main source of inspiration  I was always failing in understanding X-macros until I wrote my own

User · Answer

You could use a reflection library  like Ponder    enum class MyEnum       Zero   0      One    1      Two    2     ponder  Enum  declare lt MyEnum gt         value  Zero   MyEnum  Zero       value  One    MyEnum  One       value  Two    MyEnum  Two    ponder  EnumObject zero MyEnum  Zero    zero name       - gt   Zero

User · Answer

I wrote a library for solving this problem  everything happens in compiling time  except for getting the message   Usage   Use macro DEF MSG to define a macro and message pair   DEF MSG CODE OK     OK    DEF MSG CODE FAIL   Fail      CODE OK is the macro to use  and  OK   is the corresponding message   Use get message   or just gm   to get the message   get message CODE FAIL       will return  Fail   gm CODE FAIL                works exactly the same as above   Use MSG NUM to find out how many macros have been defined  This will automatically increse  you don t need to do anything   Predefined messages   MSG OK      OK MSG BOTTOM  Message bottom   Project  libcodemsg    The library doesn t create extra data  Everything happens in compiling time  In message def h  it generates an enum called MSG CODE  in message def c  it generates a variable holds all the strings in static const char   g messages     In such case  the library is limited to create one enum only  This is ideal for return values  for example   MSG CODE foo void        return MSG OK     or something else    MSG CODE ret   foo     if  MSG OK    ret        printf   s n   gm ret         Another thing I like this design is you can manage message definitions in different files     I found the solution to this question looks much better

User · Answer

EDIT  check below for a newer version  As mentioned above  N4113 is the final solution to this matter  but we ll have to wait more than a year to see it coming out     Meanwhile  if you want such feature  you ll need to resort to  simple  templates and some preprocessor magic     Enumerator  template lt typename T gt  class Enum final       const char  m name      const T m value      static T m counter   public      Enum const char  str  T init   m counter    m name str   m value init   m counter    init   1         const T value   const  return m value       const char  name   const  return m name       template lt typename T gt  T Enum lt T gt   m counter   0    define ENUM TYPE x       using Enum   Enum lt x gt    define ENUM DECL x       x  x     VA ARGS     define ENUM              const Enum ENUM DECL   VA ARGS       Usage   include  lt iostream gt     the initialization order should be correct in all scenarios namespace Level       ENUM TYPE std  uint8      ENUM OFF      ENUM SEVERE      ENUM WARNING      ENUM INFO  10      ENUM DEBUG      ENUM ALL     namespace Example       ENUM TYPE long      ENUM A      ENUM B      ENUM C  20      ENUM D      ENUM E      ENUM F     int main int argc  char   argv        Level  Enum lvl   Level  WARNING      Example  Enum ex   Example  C      std  cout  lt  lt  lvl value    lt  lt  std  endl    2     std  cout  lt  lt  ex value    lt  lt  std  endl    20     Simple explaination  Enum lt T gt   m counter is set to 0 inside each namespace declaration   Could someone point me out where   this behaviour   is mentioned on the standard   The preprocessor magic automates the declaration of enumerators   Disadvantages   It s not a true enum type  therefore not promotable to int Cannot be used in switch cases     Alternative solution  This one sacrifices line numbering  not really  but can be used on switch cases    define ENUM TYPE x  using type   Enum lt x gt   define ENUM x       constexpr type x   LINE    x   template lt typename T gt  struct Enum final       const T value      const char  name       constexpr operator const T   const noexcept  return value       constexpr const char  operator amp    const noexcept  return name        Errata   line 0 conflicts with -pedantic on GCC and clang   Workaround  Either start at  line 1 and subtract 1 from   LINE    Or  don t use -pedantic  And while we re at it  avoid VC   at all costs  it has always been a joke of a compiler   Usage   include  lt iostream gt   namespace Level       ENUM TYPE short        line 0     ENUM OFF       ENUM SEVERE       ENUM WARNING        line 10     ENUM INFO       ENUM DEBUG       ENUM ALL        line  lt next line number gt    restore the line numbering     int main int argc  char   argv        std  cout  lt  lt  Level  OFF  lt  lt  std  endl       0     std  cout  lt  lt   amp Level  OFF  lt  lt  std  endl      OFF      std  cout  lt  lt  Level  INFO  lt  lt  std  endl      10     std  cout  lt  lt   amp Level  INFO  lt  lt  std  endl     INFO      switch    any integer or integer-convertible type               case Level  OFF                        break       case Level  SEVERE                        break                        return 0      Real-life implementation and use  r3dVoxel - Enum r3dVoxel - ELoggingLevel  Quick Reference   line lineno -- cppreference com

User · Answer

Very simple solution with one big constraint  you can t assign custom values to enum values  but with the right regex  you could  you could also add a map to translate them back to enum values without much more effort    include  lt vector gt   include  lt string gt   include  lt regex gt   include  lt iterator gt   std  vector lt std  string gt  split const std  string amp  s                                  const std  regex amp  delim   std  regex     s           using namespace std      vector lt string gt  cont      copy regex token iterator lt string  const iterator gt  s begin    s end    delim  -1             regex token iterator lt string  const iterator gt              back inserter cont        return cont      define EnumType Type           enum class Type     VA ARGS       define EnumStrings Type        static const std  vector lt std  string gt                                    Type  Strings   split    VA ARGS       define EnumToString Type       EnumType Type    VA ARGS                                       EnumStrings Type    VA ARGS      Usage example   EnumToString MyEnum  Red  Green  Blue

User · Answer

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

User · Answer

If your enum looks  like  enum MyEnum     AAA   -8    BBB    8     CCC   AAA   BBB      You can move the content of the enum to a new file   AAA   -8  BBB    8   CCC   AAA   BBB   And then the values can be surrounded by a macro      default definition  ifned ITEM X Y   define ITEM X Y   endif     Items list ITEM AAA -8  ITEM BBB  8   ITEM CCC AAA BBB      clean up  undef ITEM   Next step may be include the items in the enum again   enum MyEnum      define ITEM X Y  X Y     include  enum definition file       And finally you can generate utility functions about this enum   std  string ToString MyEnum value      switch  value            define ITEM X Y  case X  return  X       include  enum definition file         return        MyEnum FromString std  string const amp  value      static std  map lt std  string MyEnum gt  converter          define ITEM X Y     X  X         include  enum definition file          auto it   converter find value     if  it    converter end         return it- gt second    else     throw std  runtime error  Value is missing        The solution can be applied to older C   standards and it does not use modern C   elements but it can be used to generate lot of code without too much effort and maintenance

User · Answer

Analogue of https   stackoverflow com a 54967187 2338477  slightly modified    Here is my own solution with minimum define magic and support of individual enum assignments   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 cppscriptcore blob master SolutionProjectModel EnumReflect h

User · Answer

My solution  using a preprocessor define  You can check this code on https   repl it  JomaCorpFX nameof main cpp  include  lt iostream gt   include  lt stdexcept gt   include  lt regex gt   typedef std  string String  using namespace std  literals  string literals   class Strings   public      static String TrimStart const std  string amp  data                String s   data          s erase s begin    std  find if s begin    s end       unsigned char ch                return  std  isspace ch                        return s             static String TrimEnd const std  string amp  data                String s   data          s erase std  find if s rbegin    s rend       unsigned char ch                return  std  isspace ch              base                s end             return s             static String Trim const std  string amp  data                return TrimEnd TrimStart data               static String Replace const String amp  data  const String amp  toFind  const String amp  toReplace                String result   data          size t pos   0          while   pos   result find toFind  pos      String  npos                        result replace pos  toFind length    toReplace               pos    toReplace length                pos   result find toFind  pos                     return result             static String Nameof const String amp  name        std  smatch groups      String str   Strings  Trim name       if  std  regex match str  groups  std  regex u8R quot    amp     a-zA-Z  w  - gt             a-zA-Z  w     quot                   if  groups size      4                        return groups 3                       throw std  invalid argument Strings  Replace u8R quot  nameof     Invalid identifier  quot   quot    quot   u8 quot   quot   name        define nameof name  Nameof u8    name    s   define cnameof name  Nameof u8    name    s  c str    enum TokenType       COMMA      PERIOD      Q MARK     struct MyClass       enum class MyEnum   char           AAA   -8          BBB    8           CCC   AAA   BBB            int main         String greetings   u8 quot Hello quot s      std  cout  lt  lt  nameof COMMA   lt  lt  std  endl      std  cout  lt  lt  nameof TokenType  PERIOD   lt  lt  std  endl      std  cout  lt  lt  nameof TokenType  Q MARK   lt  lt  std  endl      std  cout  lt  lt  nameof int   lt  lt  std  endl      std  cout  lt  lt  nameof std  string   lt  lt  std  endl      std  cout  lt  lt  nameof Strings   lt  lt  std  endl      std  cout  lt  lt  nameof String   lt  lt  std  endl      std  cout  lt  lt  nameof greetings   lt  lt  std  endl      std  cout  lt  lt  nameof  amp greetings   lt  lt  std  endl      std  cout  lt  lt  nameof greetings c str   lt  lt  std  endl      std  cout  lt  lt  nameof std  string  npos   lt  lt  std  endl      std  cout  lt  lt  nameof MyClass  MyEnum  AAA   lt  lt  std  endl      std  cout  lt  lt  nameof MyClass  MyEnum  BBB   lt  lt  std  endl      std  cout  lt  lt  nameof MyClass  MyEnum  CCC   lt  lt  std  endl        std  cin get        return 0     Output COMMA PERIOD Q MARK int string Strings String greetings greetings c str npos AAA BBB CCC  Clang  Visual C

User · Answer

As per request from the OP  here a stripped down version of the ugly macro solution based on Boost Preprosessor and Variadic Macros    It allows for a simple list like syntax of the enumerator elements along with setting values for specific elements so that  XXX ENUM foo  a b  c 42       expands to  enum foo       a      b      c 42      Alongside with the necessary functions to output and do some conversion back  This macro has been around here for ages  and I am not totally sure that its the most efficient way  or that it is a conforming way  but it has ever since been working  The complete code can be seen in action at both Ideone and Coliru    Its gargantuan ugliness is above  I would have put it behind spoilers to protect your eyes  if I knew how  but markdown doesn t like me   The library  merged within one single header file    include  lt boost preprocessor hpp gt   include  lt string gt   include  lt unordered map gt   namespace xxx    template lt class T gt  struct enum cast adl helper       template lt class E gt  E enum cast  const std  string amp  s         return do enum cast s enum cast adl helper lt E gt         template lt class E gt  E enum cast  const char  cs         std  string s cs       return enum cast lt E gt  s           namespace xxx   define XXX PP ARG N                                           1   2   3   4   5   6   7   8   9  10              11  12  13  14  15  16  17  18  19  20              21  22  23  24  25  26  27  28  29  30              31  32  33  34  35  36  37  38  39  40              41  42  43  44  45  46  47  48  49  50              51  52  53  54  55  56  57  58  59  60              61  62  63 N      N   define XXX PP RSEQ N                              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 0    define XXX PP NARG       XXX PP ARG N   VA ARGS     define XXX PP NARG       XXX PP NARG    VA ARGS   XXX PP RSEQ N     define XXX TUPLE SIZE INTERNAL TUPLE  XXX PP NARG TUPLE   define XXX TUPLE CHOICE i                                 BOOST PP APPLY                                             BOOST PP TUPLE ELEM                                        25  i                                                       0    1    2    3    4    5    6    7    8                9    10    11    12    13    14    15    16              17    18    19    20    21    22    23    24              define BOOST PP BOOL 00  BOOST PP BOOL 0  define BOOST PP BOOL 01  BOOST PP BOOL 1  define BOOST PP BOOL 02  BOOST PP BOOL 2  define BOOST PP BOOL 03  BOOST PP BOOL 3  define BOOST PP BOOL 04  BOOST PP BOOL 4  define BOOST PP BOOL 05  BOOST PP BOOL 5  define BOOST PP BOOL 06  BOOST PP BOOL 6  define BOOST PP BOOL 07  BOOST PP BOOL 7  define BOOST PP BOOL 08  BOOST PP BOOL 8  define BOOST PP BOOL 09  BOOST PP BOOL 9  define BOOST PP BOOL 010 BOOST PP BOOL 10  define BOOST PP BOOL 011 BOOST PP BOOL 11  define BOOST PP BOOL 012 BOOST PP BOOL 12  define BOOST PP BOOL 013 BOOST PP BOOL 13  define BOOST PP BOOL 014 BOOST PP BOOL 14  define BOOST PP BOOL 015 BOOST PP BOOL 15  define BOOST PP BOOL 016 BOOST PP BOOL 16  define BOOST PP BOOL 017 BOOST PP BOOL 17  define BOOST PP BOOL 018 BOOST PP BOOL 18  define BOOST PP BOOL 019 BOOST PP BOOL 19  define BOOST PP BOOL 020 BOOST PP BOOL 20  define BOOST PP BOOL 021 BOOST PP BOOL 21  define BOOST PP BOOL 022 BOOST PP BOOL 22  define BOOST PP BOOL 023 BOOST PP BOOL 23  define BOOST PP BOOL 024 BOOST PP BOOL 24  define BOOST PP BOOL 025 BOOST PP BOOL 25  define BOOST PP BOOL 026 BOOST PP BOOL 26  define BOOST PP BOOL 027 BOOST PP BOOL 27  define BOOST PP BOOL 028 BOOST PP BOOL 28  define BOOST PP BOOL 029 BOOST PP BOOL 29  define BOOST PP BOOL 030 BOOST PP BOOL 30  define BOOST PP BOOL 031 BOOST PP BOOL 31  define BOOST PP BOOL 032 BOOST PP BOOL 32  define BOOST PP BOOL 033 BOOST PP BOOL 33  define BOOST PP BOOL 034 BOOST PP BOOL 34  define BOOST PP BOOL 035 BOOST PP BOOL 35  define BOOST PP BOOL 036 BOOST PP BOOL 36  define BOOST PP BOOL 037 BOOST PP BOOL 37  define BOOST PP BOOL 038 BOOST PP BOOL 38  define BOOST PP BOOL 039 BOOST PP BOOL 39  define BOOST PP BOOL 040 BOOST PP BOOL 40  define BOOST PP BOOL 041 BOOST PP BOOL 41  define BOOST PP BOOL 042 BOOST PP BOOL 42  define BOOST PP BOOL 043 BOOST PP BOOL 43  define BOOST PP BOOL 044 BOOST PP BOOL 44  define BOOST PP BOOL 045 BOOST PP BOOL 45  define BOOST PP BOOL 046 BOOST PP BOOL 46  define BOOST PP BOOL 047 BOOST PP BOOL 47  define BOOST PP BOOL 048 BOOST PP BOOL 48  define BOOST PP BOOL 049 BOOST PP BOOL 49  define BOOST PP BOOL 050 BOOST PP BOOL 50  define BOOST PP BOOL 051 BOOST PP BOOL 51  define BOOST PP BOOL 052 BOOST PP BOOL 52  define BOOST PP BOOL 053 BOOST PP BOOL 53  define BOOST PP BOOL 054 BOOST PP BOOL 54  define BOOST PP BOOL 055 BOOST PP BOOL 55  define BOOST PP BOOL 056 BOOST PP BOOL 56  define BOOST PP BOOL 057 BOOST PP BOOL 57  define BOOST PP BOOL 058 BOOST PP BOOL 58  define BOOST PP BOOL 059 BOOST PP BOOL 59  define BOOST PP BOOL 060 BOOST PP BOOL 60  define BOOST PP BOOL 061 BOOST PP BOOL 61  define BOOST PP BOOL 062 BOOST PP BOOL 62  define BOOST PP BOOL 063 BOOST PP BOOL 63   define BOOST PP DEC 00  BOOST PP DEC 0  define BOOST PP DEC 01  BOOST PP DEC 1  define BOOST PP DEC 02  BOOST PP DEC 2  define BOOST PP DEC 03  BOOST PP DEC 3  define BOOST PP DEC 04  BOOST PP DEC 4  define BOOST PP DEC 05  BOOST PP DEC 5  define BOOST PP DEC 06  BOOST PP DEC 6  define BOOST PP DEC 07  BOOST PP DEC 7  define BOOST PP DEC 08  BOOST PP DEC 8  define BOOST PP DEC 09  BOOST PP DEC 9  define BOOST PP DEC 010 BOOST PP DEC 10  define BOOST PP DEC 011 BOOST PP DEC 11  define BOOST PP DEC 012 BOOST PP DEC 12  define BOOST PP DEC 013 BOOST PP DEC 13  define BOOST PP DEC 014 BOOST PP DEC 14  define BOOST PP DEC 015 BOOST PP DEC 15  define BOOST PP DEC 016 BOOST PP DEC 16  define BOOST PP DEC 017 BOOST PP DEC 17  define BOOST PP DEC 018 BOOST PP DEC 18  define BOOST PP DEC 019 BOOST PP DEC 19  define BOOST PP DEC 020 BOOST PP DEC 20  define BOOST PP DEC 021 BOOST PP DEC 21  define BOOST PP DEC 022 BOOST PP DEC 22  define BOOST PP DEC 023 BOOST PP DEC 23  define BOOST PP DEC 024 BOOST PP DEC 24  define BOOST PP DEC 025 BOOST PP DEC 25  define BOOST PP DEC 026 BOOST PP DEC 26  define BOOST PP DEC 027 BOOST PP DEC 27  define BOOST PP DEC 028 BOOST PP DEC 28  define BOOST PP DEC 029 BOOST PP DEC 29  define BOOST PP DEC 030 BOOST PP DEC 30  define BOOST PP DEC 031 BOOST PP DEC 31  define BOOST PP DEC 032 BOOST PP DEC 32  define BOOST PP DEC 033 BOOST PP DEC 33  define BOOST PP DEC 034 BOOST PP DEC 34  define BOOST PP DEC 035 BOOST PP DEC 35  define BOOST PP DEC 036 BOOST PP DEC 36  define BOOST PP DEC 037 BOOST PP DEC 37  define BOOST PP DEC 038 BOOST PP DEC 38  define BOOST PP DEC 039 BOOST PP DEC 39  define BOOST PP DEC 040 BOOST PP DEC 40  define BOOST PP DEC 041 BOOST PP DEC 41  define BOOST PP DEC 042 BOOST PP DEC 42  define BOOST PP DEC 043 BOOST PP DEC 43  define BOOST PP DEC 044 BOOST PP DEC 44  define BOOST PP DEC 045 BOOST PP DEC 45  define BOOST PP DEC 046 BOOST PP DEC 46  define BOOST PP DEC 047 BOOST PP DEC 47  define BOOST PP DEC 048 BOOST PP DEC 48  define BOOST PP DEC 049 BOOST PP DEC 49  define BOOST PP DEC 050 BOOST PP DEC 50  define BOOST PP DEC 051 BOOST PP DEC 51  define BOOST PP DEC 052 BOOST PP DEC 52  define BOOST PP DEC 053 BOOST PP DEC 53  define BOOST PP DEC 054 BOOST PP DEC 54  define BOOST PP DEC 055 BOOST PP DEC 55  define BOOST PP DEC 056 BOOST PP DEC 56  define BOOST PP DEC 057 BOOST PP DEC 57  define BOOST PP DEC 058 BOOST PP DEC 58  define BOOST PP DEC 059 BOOST PP DEC 59  define BOOST PP DEC 060 BOOST PP DEC 60  define BOOST PP DEC 061 BOOST PP DEC 61  define BOOST PP DEC 062 BOOST PP DEC 62  define BOOST PP DEC 063 BOOST PP DEC 63   define XXX TO NUMx x  0    x  define XXX TO NUM x  BOOST PP ADD 0 XXX TO NUMx x    define XXX STRINGIZEX x    x  define XXX VSTRINGIZE SINGLE a b x  XXX STRINGIZE x   define XXX VSTRINGIZE TUPLE tpl  XXX TUPLE FOR EACH XXX VSTRINGIZE SINGLE  tpl   define XXX TUPLE SIZE TUPLE  XXX TO NUM XXX TUPLE CHOICE XXX TUPLE SIZE INTERNAL TUPLE     define XXX TUPLE FOR EACH MACRO DATA TUPLE  BOOST PP LIST FOR EACH MACRO DATA BOOST PP TUPLE TO LIST XXX TUPLE SIZE TUPLE  TUPLE    define XXX STRINGIZE x  XXX STRINGIZEX x   define XXX VSTRINGIZE      XXX VSTRINGIZE TUPLE    VA ARGS      define XXX CAST TO VOID ELEMENT r data elem   void  elem    define XXX CAST TO VOID INTERNAL TUPLE  XXX TUPLE FOR EACH XXX CAST TO VOID ELEMENT  TUPLE       define XXX CAST TO VOID      XXX CAST TO VOID INTERNAL    VA ARGS      define XXX ENUM EXTRACT SP en  BOOST PP TUPLE ELEM XXX TUPLE SIZE en  0 en    BOOST PP TUPLE ELEM XXX TUPLE SIZE en  1 en   define XXX ENUM ELEMENT r data elem  BOOST PP IF  XXX TUPLE SIZE elem   XXX ENUM EXTRACT SP elem   elem     define XXX ENUM EXTRACT ELEMENT en  BOOST PP TUPLE ELEM XXX TUPLE SIZE en  0 en   define XXX ENUM CASE ELEMENT en  BOOST PP IF  XXX TUPLE SIZE en   XXX ENUM EXTRACT ELEMENT en   en    define XXX ENUM CASE r data elem  case data    XXX ENUM CASE ELEMENT elem    return  data      XXX STRINGIZE XXX ENUM CASE ELEMENT elem     define XXX ENUM IFELSE r data elem  else if  en    data    XXX ENUM CASE ELEMENT elem     return  data      XXX STRINGIZE XXX ENUM CASE ELEMENT elem       define XXX ENUM CASTLIST r data elem    XXX STRINGIZE XXX ENUM CASE ELEMENT elem    data    XXX ENUM CASE ELEMENT elem      define XXX ENUM QUALIFIED CASTLIST r data elem     data      XXX STRINGIZE XXX ENUM CASE ELEMENT elem    data    XXX ENUM CASE ELEMENT elem       define XXX ENUM INTERNAL TYPE NAME TUPLE                          enum TYPE                                                                                                                                XXX TUPLE FOR EACH XXX ENUM ELEMENT  TUPLE                         BOOST PP CAT last enum  NAME                                                                                                                                                                          inline                                                             const char  to string  NAME en                                                                                                           if false                                                                                                                                                                                                 XXX TUPLE FOR EACH XXX ENUM IFELSE NAME TUPLE                      else if  en    NAME    BOOST PP CAT last enum  NAME                                                                                     return XXX VSTRINGIZE NAME    BOOST PP CAT last enum  NAME                                                                             else                                                                                                                                    return  Invalid enum value specified for     NAME                                                                                                                                                                                                                      inline                                                             std  ostream amp  operator lt  lt   std  ostream amp  os  const NAME amp  en                                                                               os  lt  lt  to string en                                                 return os                                                                                                                                                                                             inline                                                             NAME do enum cast  const std  string amp  s  const   xxx  enum cast adl helper lt NAME gt  amp                                                                           static const std  unordered map lt std  string NAME gt  map                                                                                   XXX TUPLE FOR EACH XXX ENUM CASTLIST NAME TUPLE                    XXX TUPLE FOR EACH XXX ENUM QUALIFIED CASTLIST NAME TUPLE                                                                                                                                              auto cit   map find s                                              if  cit    map end                                                                                                                      throw std  runtime error  Invalid value to cast to enum                                                                             return cit- gt second                                                   define XXX ENUM NAME TUPLE  XXX ENUM INTERNAL NAME NAME TUPLE   define XXX ENUM CLASS NAME TUPLE  XXX ENUM INTERNAL class NAME NAME TUPLE   define XXX ENUM CLASS TYPE NAME TYPE TUPLE  XXX ENUM INTERNAL class NAME   TYPE NAME TUPLE   define XXX ENUM TYPE NAME TYPE TUPLE  XXX ENUM INTERNAL NAME   TYPE NAME TUPLE    Usage   include  xxx enum h      the above lib  include  lt iostream gt   XXX ENUM foo  a b  c 42      int main       std  cout  lt  lt   foo  a                 lt  lt  foo  a             lt  lt   n     std  cout  lt  lt    int foo  c            lt  lt   int foo  c        lt  lt   n     std  cout  lt  lt   to string foo  b       lt  lt  to string foo  b   lt  lt   n     std  cout  lt  lt   xxx  enum cast lt foo gt    b         lt  lt  xxx  enum cast lt foo gt   b    lt  lt   n       Compilation  copy paste header within main cpp    gt  g   --version   sed 1q g    GCC  4 9 2   gt  g   -std c  14 -pedantic -Wall -Wextra main cpp main cpp 268 31  warning  extra      -Wpedantic       XXX ENUM foo  a b  c 42                                        Output  foo  a   foo  a  int foo  c   42 to string foo  b    foo  b xxx  enum cast lt foo gt   b     foo  b

User · Answer

My answer is here    You can get enum value names and these indices simultaneously as deque of string    This method only needs little copy and paste and edit   Obtained result needs type-casting from size t to enum class type when you need enum class type value  but I think it is a very portable and powerful way to treat enum class   enum class myenum     one   0    two    three      deque lt string gt  ssplit const string  amp  src  boost  regex  amp  re      boost  sregex token iterator it  src begin     src end     re  -1     boost  sregex token iterator e    deque lt string gt  tokens    while  it    e      tokens push back  it       return std  move tokens      int main       regex re         deque lt string gt  tokens   ssplit  one two three   re     for  auto  amp t   tokens  cout  lt  lt  t  lt  lt  endl      getchar      return 0

User · Answer

I had the same problem a couple of days ago  I couldn t find any C   solution without some weird macro magic  so I decided to write a CMake code generator to generate simple switch case statements   Usage   enum2str generate    PATH           lt path to place the files in gt    CLASS NAME     lt name of the class  also prefix for the files  gt    FUNC NAME      lt name of the  static  member function gt    NAMESPACE      lt the class will be inside this namespace gt    INCLUDES       lt LIST of files where the enums are defined gt    ENUMS          lt LIST of enums to process gt    BLACKLIST      lt LIST of constants to ignore gt    USE CONSTEXPR  lt whether to use constexpr or not  default  off  gt    USE C STRINGS  lt whether to use c strings instead of std  string or not  default  off  gt      The function searches the include files in the filesystem  uses the include directories provided with the include directories command   reads them and does some regex to generate the class and the function s    NOTE  constexpr implies inline in C    so using the USE CONSTEXPR option will generate a header only class   Example     includes a h   enum AAA   char   A1  A2     typedef enum      VAL1            0     VAL2            1     VAL3            2     VAL FIRST       VAL1        Ignored    VAL LAST        VAL3        Ignored    VAL DUPLICATE   1           Ignored    VAL STRANGE     VAL2   1    Must be blacklisted   BBB      CMakeLists txt   include directories    PROJECT SOURCE DIR  includes       enum2str generate     PATH          PROJECT SOURCE DIR      CLASS NAME  enum2Str     NAMESPACE   abc     FUNC NAME   toStr     INCLUDES    a h    WITHOUT directory    ENUMS       AAA   BBB     BLACKLIST   VAL STRANGE     Generates     enum2Str hpp            file enum2Str hpp      warning This is an automatically generated file         ifndef ENUM2STR HPP  define ENUM2STR HPP   include  lt string gt   include  lt a h gt   namespace abc    class enum2Str    public     static std  string toStr  AAA  var   noexcept     static std  string toStr  BBB  var   noexcept          endif    ENUM2STR HPP     enum2Str cpp            file enum2Str cpp      warning This is an automatically generated file         include  enum2Str hpp   namespace abc            brief Converts the enum AAA to a std  string     param  var The enum value to convert     returns  var converted to a std  string     std  string enum2Str  toStr  AAA  var   noexcept      switch    var           case A1  return  A1         case A2  return  A2         default  return   lt UNKNOWN gt                    brief Converts the enum BBB to a std  string     param  var The enum value to convert     returns  var converted to a std  string     std  string enum2Str  toStr  BBB  var   noexcept      switch    var           case VAL1  return  VAL1         case VAL2  return  VAL2         case VAL3  return  VAL3         default  return   lt UNKNOWN gt               Update   The script now also supports scoped enumerations  enum class struct  and I moved it to a seperate repo with some other scripts I often use  https   github com mensinda cmakeBuildTools

User · Answer

What about a simple streaming overload  You still have to maintain the mapping if you don t want to do some macro magic  but I find it cleaner than your original solution    include  lt cstdint gt      for std  uint fast8 t  include  lt array gt   include  lt string gt   include  lt iostream gt   enum class MyEnum   std  uint fast8 t      AAA     BBB     CCC      std  ostream amp  operator lt  lt  std  ostream amp  str  MyEnum type        switch type            case MyEnum  AAA  str  lt  lt   AAA   break      case MyEnum  BBB  str  lt  lt   BBB   break      case MyEnum  CCC  str  lt  lt   CCC   break      default  break            return str     int main        std  cout  lt  lt  MyEnum  AAA  lt  lt   n

User · Answer

define ENUM MAKE TYPE                 enum class TYPE    VA ARGS              struct Helper     TYPE                 static const String amp  toName TYPE type                     int index   static cast lt int gt  type                    return splitStringVec   index                 static const TYPE toType const String amp  name                    static std  unordered map lt String TYPE gt  typeNameMap                   if  typeNameMap empty                                             const StringVector amp  ssVec   splitStringVec                         for  size t i   0  i  lt  ssVec size      i                           typeNameMap insert std  make pair ssVec i   static cast lt TYPE gt  i                                         return typeNameMap name                 static const StringVector amp  splitStringVec                      static StringVector typeNameVector                   if typeNameVector empty                                             typeNameVector   StringUtil  split    VA ARGS                               for  auto amp  name   typeNameVector                                                  name erase std  remove name begin    name end         name end                               name   String  TYPE           name                                                             return typeNameVector                               using String   std  string  using StringVector   std  vector lt String gt       StringVector StringUtil  split  const String amp  str  const String amp  delims  unsigned int maxSplits  bool preserveDelims                StringVector ret             Pre-allocate some space for performance         ret reserve maxSplits   maxSplits 1   10         10 is guessed capacity for most case          unsigned int numSplits   0              Use STL methods          size t start  pos          start   0          do                        pos   str find first of delims  start               if  pos    start                                   Do nothing                 start   pos   1                            else if  pos    String  npos     maxSplits  amp  amp  numSplits    maxSplits                                    Copy the rest of the string                 ret push back  str substr start                     break                            else                                  Copy up to delimiter                 ret push back  str substr start  pos - start                      if preserveDelims                                           Sometimes there could be more than one delimiter in a row                         Loop until we don t find any more delims                     size t delimStart   pos  delimPos                      delimPos   str find first not of delims  delimStart                       if  delimPos    String  npos                                                   Copy the rest of the string                         ret push back  str substr delimStart                                               else                                               ret push back  str substr delimStart  delimPos - delimStart                                                              start   pos   1                               parse up to next real data             start   str find first not of delims  start                 numSplits             while  pos    String  npos              return ret          example  ENUM MAKE MY TEST  MY 1  MY 2  MY 3        MY TEST s1   MY TEST  MY 1      MY TEST s2   MY TEST  MY 2      MY TEST s3   MY TEST  MY 3       String z1   Helper MY TEST  toName s1       String z2   Helper MY TEST  toName s2       String z3   Helper MY TEST  toName s3        MY TEST q1   Helper MY TEST  toType z1       MY TEST q2   Helper MY TEST  toType z2       MY TEST q3   Helper MY TEST  toType z3     automatically ENUM MAKE macro generate  enum class  and helper class with  enum reflection function     In order to reduce mistakes  at once Everything is defined with only one ENUM MAKE    The advantage of this code is automatically created for reflection and a close look at macro code  easy-to-understand code   enum to string     string to enum  performance both is algorithm O 1    Disadvantages is when first use   helper class for enum relection  s string vector and map is initialized  but If you want you ll also be pre-initialized

User · Answer

My 3 cents  though this is not a complete match to what the op wants  Here is the relevant reference  namespace enums    template  lt typename T  T I  char    Chars gt  struct enums   std  integral constant lt T  I gt      static constexpr char const chars sizeof    Chars   Chars          template  lt typename T  T X  typename S  std  size t    I gt  constexpr auto make std  index sequence lt I    gt   noexcept     return enums lt T  X  S   chars I     gt         define ENUM s  n       noexcept     struct S   char const   amp chars  sizeof s   s         return enums  make lt decltype n   n  S gt        std  make index sequence lt sizeof s  gt           define ENUM T s  n     static constexpr auto s     tmp ENUM  s  n       using s     enum t   decltype s     tmp   template  lt typename T  typename    A  std  size t N gt  inline auto map char const   amp s  N   noexcept     constexpr auto invalid  T        auto r invalid      return                       invalid    r             r   std  strncmp A  chars  s  N    invalid   A               r                                 int main       ENUM T echo  0     ENUM T cat  1     ENUM T ls  2      std  cout  lt  lt  echo enum t    lt  lt   quot   quot   lt  lt  echo enum t  chars  lt  lt  std  endl     std  cout  lt  lt  enums  map lt int  echo enum t  cat enum t  ls enum t gt   quot ls quot     lt  lt  std  endl     return 0     So you generate a type  that you can convert to an integer and or a string

User · Answer

I don t know if you re going to like this or not  I m not pretty happy with this solution but it is a C  14 friendly approach because it is using template variables and abusing template specialization  enum class MyEnum   std  uint fast8 t      AAA     BBB     CCC      template lt MyEnum gt  const char MyEnumName      quot Invalid MyEnum value quot   template lt  gt  const char MyEnumName lt MyEnum  AAA gt       quot AAA quot   template lt  gt  const char MyEnumName lt MyEnum  BBB gt       quot BBB quot   template lt  gt  const char MyEnumName lt MyEnum  CCC gt       quot CCC quot    int main            Prints  quot AAA quot      std  cout  lt  lt  MyEnumName lt MyEnum  AAA gt   lt  lt    n          Prints  quot Invalid MyEnum value quot      std  cout  lt  lt  MyEnumName lt static cast lt MyEnum gt  0x12345678  gt   lt  lt    n          Well    in fact it prints  quot Invalid MyEnum value quot  for any value        different of MyEnum  AAA  MyEnum  BBB or MyEnum  CCC       return 0     The worst about this approach is that is a pain to maintain  but it is also a pain to maintain some of other similar aproaches  aren t they  Good points about this aproach   Using variable tempates  C  14 feature  With template specialization we can  quot detect quot  when an invalid value is used  but I m not sure if this could be useful at all   It looks neat  The name lookup is done at compile time   Live example Edit Misterious user673679 you re right  the C  14 variable template approach doesn t handles the runtime case  it was my fault to forget it    But we can still use some modern C   features and variable template plus variadic template trickery to achieve a runtime translation from enum value to string    it is as bothersome as the others but still worth to mention  Let s start using a template alias to shorten the access to a enum-to-string map     enum map contains pairs of enum value and value string for each enum    this shortcut allows us to use enum map lt whatever gt   template  lt typename ENUM gt  using enum map   std  map lt ENUM  const std  string gt       This variable template will create a map for each enum type which is    instantiated with  template  lt typename ENUM gt  enum map lt ENUM gt  enum values     Then  the variadic template trickery  template  lt typename ENUM gt  void initialize       template  lt typename ENUM  typename     args gt  void initialize const ENUM value  const char  name  args     tail        enum values lt ENUM gt  emplace value  name       initialize lt ENUM gt  tail          The  quot best trick quot  here is the use of variable template for the map which contains the values and names of each enum entry  this map will be the same in each translation unit and have the same name everywhere so is pretty straightforward and neat  if we call the initialize function like this  initialize       MyEnum  AAA   quot AAA quot       MyEnum  BBB   quot BBB quot       MyEnum  CCC   quot CCC quot      We are asigning names to each MyEnum entry and can be used in runtime  std  cout  lt  lt  enum values lt MyEnum gt  MyEnum  AAA   lt  lt    n    But can be improved with SFINAE and overloading  lt  lt  operator  template lt typename ENUM  class   typename std  enable if lt std  is enum lt ENUM gt   value gt   type gt  std  ostream  amp operator  lt  lt  std  ostream  amp o  const ENUM value        static const std  string Unknown std  string typeid ENUM  name       quot  unknown value quot        auto found   enum values lt ENUM gt  find value        return o  lt  lt   found    enum values lt ENUM gt  end     Unknown   found- gt second      With the correct operator  lt  lt  now we can use the enum this way  std  cout  lt  lt  MyEnum  AAA  lt  lt    n    This is also bothersome to maintain and can be improved  but hope you get the idea  Live example

User · Answer

Magic Enum header-only library provides static reflection for enums  to string  from string  iteration  for C  17    include  lt magic enum hpp gt   enum Color   RED   2  BLUE   4  GREEN   8     Color color   Color  RED  auto color name   magic enum  enum name color      color name - gt   RED   std  string color name  GREEN    auto color   magic enum  enum cast lt Color gt  color name  if  color has value           color value   - gt  Color  GREEN      For more examples check home repository https   github com Neargye magic enum   Where is the drawback   This library uses a compiler-specific hack  based on   PRETTY FUNCTION       FUNCSIG     which works on Clang    5  MSVC    15 3 and GCC    9   Enum value must be in range  MAGIC ENUM RANGE MIN  MAGIC ENUM RANGE MAX     By default MAGIC ENUM RANGE MIN   -128  MAGIC ENUM RANGE MAX   128  If need another range for all enum types by default  redefine the macro MAGIC ENUM RANGE MIN and MAGIC ENUM RANGE MAX  MAGIC ENUM RANGE MIN must be less or equals than 0 and must be greater than INT16 MIN  MAGIC ENUM RANGE MAX must be greater than 0 and must be less than INT16 MAX  If need another range for specific enum type  add specialization enum range for necessary enum type    include  lt magic enum hpp gt   enum number   one   100  two   200  three   300     namespace magic enum   template  lt  gt    struct enum range lt number gt        static constexpr int min   100      static constexpr int max   300

User · Answer

This is similar to Yuri Finkelstein  but does not required boost  I am using a map so you can assign any value to the enums  any order   Declaration of enum class as   DECLARE ENUM WITH TYPE TestEnumClass  int32 t  ZERO   0x00  TWO   0x02  ONE   0x01  THREE   0x03  FOUR     The following code will automatically create the enum class and overload             for std  string   lt  lt   for streams     just to convert to string  Any unary operator will do  but I personally don t like it for clarity      to get the count of enums   No boost required  all required functions provided   Code    include  lt algorithm gt   include  lt iostream gt   include  lt map gt   include  lt sstream gt   include  lt string gt   include  lt vector gt    define STRING REMOVE CHAR str  ch  str erase std  remove str begin    str end    ch   str end     std  vector lt std  string gt  splitString std  string str  char sep              std  vector lt std  string gt  vecString      std  string item       std  stringstream stringStream str        while  std  getline stringStream  item  sep                 vecString push back item              return vecString      define DECLARE ENUM WITH TYPE E  T                                                                                 enum class E   T                                                                                                                                                                                                                      VA ARGS                                                                                                                                                                                                                   std  map lt T  std  string gt  E  MapName generateEnumMap lt T gt     VA ARGS                                               std  ostream  amp operator lt  lt  std  ostream  amp os  E enumTmp                                                                                                                                                                                os  lt  lt  E  MapName static cast lt T gt  enumTmp                                                                         return os                                                                                                                                                                                                                   size t operator  E enumTmp     void  enumTmp  return E  MapName size                                            std  string operator  E enumTmp    return E  MapName static cast lt T gt  enumTmp                                     std  string operator  std  string  amp  amp str  E enumTmp    return str   E  MapName static cast lt T gt  enumTmp            std  string operator  E enumTmp  std  string  amp  amp str    return E  MapName static cast lt T gt  enumTmp     str          std  string  amp operator   std  string  amp str  E enumTmp                                                                                                                                                                                 str    E  MapName static cast lt T gt  enumTmp                                                                        return str                                                                                                                                                                                                                  E operator   E  amp enumTmp                                                                                                                                                                                                             auto iter   E  MapName find static cast lt T gt  enumTmp                                                              if  iter    E  MapName end      std  next iter     E  MapName end                                                   iter   E  MapName begin                                                                                     else                                                                                                                                                                                                                                  iter                                                                                                                                                                                                                      enumTmp   static cast lt E gt  iter- gt first                                                                            return enumTmp                                                                                                                                                                                                              bool valid  E T value    return  E  MapName find value     E  MapName end         define DECLARE ENUM E       DECLARE ENUM WITH TYPE E  int32 t    VA ARGS    template  lt typename T gt  std  map lt T  std  string gt  generateEnumMap std  string strMap        STRING REMOVE CHAR strMap            STRING REMOVE CHAR strMap             std  vector lt std  string gt  enumTokens splitString strMap        std  map lt T  std  string gt  retMap      T inxMap       inxMap   0      for  auto iter   enumTokens begin    iter    enumTokens end      iter                   Token   EnumName   EnumName EnumValue          std  string enumName          T enumValue          if  iter- gt find         std  string  npos                        enumName    iter                    else                       std  vector lt std  string gt  enumNameValue splitString  iter                     enumName   enumNameValue 0                 inxMap   static cast lt T gt  enumNameValue 1                if  std  is unsigned lt T gt   value                                inxMap   static cast lt T gt  std  stoull enumNameValue 1   0  0                              else                               inxMap   static cast lt T gt  std  stoll enumNameValue 1   0  0                                    retMap inxMap      enumName             return retMap      Example   DECLARE ENUM WITH TYPE TestEnumClass  int32 t  ZERO   0x00  TWO   0x02  ONE   0x01  THREE   0x03  FOUR    int main void        TestEnumClass first  second      first   TestEnumClass  FOUR      second   TestEnumClass  TWO       std  cout  lt  lt  first  lt  lt       lt  lt  static cast lt uint32 t gt  first   lt  lt       lt  lt  std  endl     FOUR 4       std  string strOne      strOne    first      std  cout  lt  lt  strOne  lt  lt  std  endl     FOUR      std  string strTwo      strTwo     Enum-    second     TestEnumClass  THREE    -test        std  cout  lt  lt  strTwo  lt  lt  std  endl     Enum-TWOTHREE-test      std  string strThree  TestEnumClass          strThree    second      std  cout  lt  lt  strThree  lt  lt  std  endl     TestEnumClass  TWO     std  cout  lt  lt   Enum count    lt  lt   first  lt  lt  std  endl      You can run the code here

User · Answer

The approach of the better enums library   There is a way to do enum to string in current C   that looks like this   ENUM Channel  char  Red   1  Green  Blue       Same as      enum class Channel   char   Red   1  Green  Blue      Usage   Channel     c   Channel   from string  Green        Channel  Green  2  c  to string                                        string  Green   for  Channel c   Channel   values        std  cout  lt  lt  c  lt  lt  std  endl      And so on      All operations can be made constexpr  You can also implement the C  17 reflection proposal mentioned in the answer by  ecatmur    There is only one macro  I believe this is the minimum possible  because preprocessor stringization     is the only way to convert a token to a string in current C    The macro is pretty unobtrusive     the constant declarations  including initializers  are pasted into a built-in enum declaration  This means they have the same syntax and meaning as in a built-in enum  Repetition is eliminated  The implementation is most natural and useful in at least C  11  due to constexpr  It can also be made to work with C  98     VA ARGS    It is definitely modern C        The macro s definition is somewhat involved  so I m answering this in several ways    The bulk of this answer is an implementation that I think is suitable for the space constraints on StackOverflow  There is also a CodeProject article describing the basics of the implementation in a long-form tutorial   Should I move it here  I think it s too much for a SO answer   There is a full-featured library  Better Enums  that implements the macro in a single header file  It also implements N4428 Type Property Queries  the current revision of the C  17 reflection proposal N4113  So  at least for enums declared through this macro  you can have the proposed C  17 enum reflection now  in C  11 C  14    It is straightforward to extend this answer to the features of the library     nothing  important  is left out here  It is  however  quite tedious  and there are compiler portability concerns   Disclaimer  I am the author of both the CodeProject article and the library   You can try the code in this answer  the library  and the implementation of N4428 live online in Wandbox  The library documentation also contains an overview of how to use it as N4428  which explains the enums portion of that proposal     Explanation  The code below implements conversions between enums and strings  However  it can be extended to do other things as well  such as iteration  This answer wraps an enum in a struct  You can also generate a traits struct alongside an enum instead   The strategy is to generate something like this   struct Channel       enum  enum   char     VA ARGS          constexpr static const Channel           values         VA ARGS          constexpr static const char   const      names          VA ARGS           static const char   to string Channel v       easy          constexpr static Channel  from string const char  s       easy           The problems are    We will end up with something like  Red   1  Green  Blue  as the initializer for the values array  This is not valid C    because Red is not an assignable expression  This is solved by casting each constant to a type T that has an assignment operator  but will drop the assignment    T Red   1   T Green   T Blue   Similarly  we will end up with   Red   1    Green    Blue   as the initializer for the names array  We will need to trim off the     1   I am not aware of a great way to do this at compile time  so we will defer this to run time  As a result   to string won t be constexpr  but  from string can still be constexpr  because we can treat whitespace and equals signs as terminators when comparing with untrimmed strings  Both the above need a  mapping  macro that can apply another macro to each element in   VA ARGS    This is pretty standard  This answer includes a simple version that can handle up to 8 elements  If the macro is to be truly self-contained  it needs to declare no static data that requires a separate definition  In practice  this means arrays need special treatment  There are two possible solutions  constexpr  or just const  arrays at namespace scope  or regular arrays in non-constexpr static inline functions  The code in this answer is for C  11 and takes the former approach  The CodeProject article is for C  98 and takes the latter      Code   include  lt cstddef gt          For size t   include  lt cstring gt          For strcspn  strncpy   include  lt stdexcept gt        For runtime error        A  typical  mapping macro  MAP macro  a  b  c       expands to    macro a  macro b  macro c         The helper macro COUNT a  b  c       expands to the number of    arguments  and IDENTITY x  is needed to control the order of    expansion of   VA ARGS   on Visual C   compilers   define MAP macro             IDENTITY            APPLY CHOOSE MAP START  COUNT   VA ARGS                    macro    VA ARGS       define CHOOSE MAP START count  MAP    count   define APPLY macro       IDENTITY macro   VA ARGS       define IDENTITY x  x   define MAP1 m  x       m x   define MAP2 m  x       m x  IDENTITY MAP1 m    VA ARGS      define MAP3 m  x       m x  IDENTITY MAP2 m    VA ARGS      define MAP4 m  x       m x  IDENTITY MAP3 m    VA ARGS      define MAP5 m  x       m x  IDENTITY MAP4 m    VA ARGS      define MAP6 m  x       m x  IDENTITY MAP5 m    VA ARGS      define MAP7 m  x       m x  IDENTITY MAP6 m    VA ARGS      define MAP8 m  x       m x  IDENTITY MAP7 m    VA ARGS       define EVALUATE COUNT  1   2   3   4   5   6   7   8  count             count   define COUNT            IDENTITY EVALUATE COUNT   VA ARGS    8  7  6  5  4  3  2  1         The type  T  mentioned above that drops assignment operations  template  lt typename U gt  struct ignore assign       constexpr explicit ignore assign U value     value value          constexpr operator U   const   return  value         constexpr const ignore assign amp  operator   int dummy  const           return  this         U    value           Prepends   ignore assign lt  underlying gt    to each argument   define IGNORE ASSIGN SINGLE e   ignore assign lt  underlying gt  e   define IGNORE ASSIGN            IDENTITY MAP IGNORE ASSIGN SINGLE    VA ARGS         Stringizes each argument   define STRINGIZE SINGLE e   e   define STRINGIZE      IDENTITY MAP STRINGIZE SINGLE    VA ARGS           Some helpers needed for  from string  constexpr const char    terminators         t r n       The size of terminators includes the implicit   0   constexpr bool is terminator char c  size t index   0        return         index  gt   sizeof terminators    false           c    terminators index    true           is terminator c  index   1      constexpr bool matches untrimmed const char  untrimmed  const char  s                                   size t index   0        return         is terminator untrimmed index     s index       0            s index     untrimmed index    false           matches untrimmed untrimmed  s  index   1           The macro proper        There are several  simplifications  in this implementation  for the    sake of brevity  First  we have only one viable option for declaring    constexpr arrays  at namespace scope  This probably should be done    two namespaces deep  one namespace that is likely to be unique for    our little enum  library   then inside it a namespace whose name is    based on the name of the enum to avoid collisions with other enums     I am using only one level of nesting        Declaring constexpr arrays inside the struct is not viable because    they will need out-of-line definitions  which will result in    duplicate symbols when linking  This can be solved with weak    symbols  but that is compiler- and system-specific  It is not    possible to declare constexpr arrays as static variables in    constexpr functions due to the restrictions on such functions        Note that this prevents the use of this macro anywhere except at    namespace scope  Ironically  the C  98 version of this  which can    declare static arrays inside static member functions  is actually    more flexible in this regard  It is shown in the CodeProject    article        Second  for compilation performance reasons  it is best to separate    the macro into a  parametric  portion  and the portion that depends    on knowing   VA ARGS    and factor the former out into a template        Third  this code uses a default parameter in  from string that may    be better not exposed in the public interface    define ENUM EnumName  Underlying                                       namespace data     EnumName                                                 using  underlying   Underlying                                          enum     VA ARGS                                                                                                                                constexpr const size t            size                                      IDENTITY COUNT   VA ARGS                                                                                                                    constexpr const  underlying       values                                      IDENTITY IGNORE ASSIGN   VA ARGS                                                                                                          constexpr const char   const      raw names                                   IDENTITY STRINGIZE   VA ARGS                                                                                                                                                                                  struct EnumName                                                             using  underlying   Underlying                                          enum  enum    underlying     VA ARGS                                                                                                            const char    to string   const                                                                                                                     for  size t index   0  index  lt  data     EnumName   size                        index                                                                                                                                        if  data     EnumName   values index      value                             return  trimmed names   index                                                                                                                                                                                   throw std  runtime error  invalid value                                                                                                                                                                             constexpr static EnumName  from string const char  s                                                           size t index   0                                                                                             return                                                                      index  gt   data     EnumName   size                                               throw std  runtime error  invalid identifier                    matches untrimmed                                                           data     EnumName   raw names index   s                                      EnumName   enum data     EnumName   values                                                                     index                    from string s  index   1                                                                                                                                                                                       EnumName     delete                                                     constexpr EnumName  enum value     value value                          constexpr operator  enum   const   return   enum  value                                                                                       private                                                                    underlying      value                                                                                                                          static const char   const    trimmed names                                                                                                          static char      the names data     EnumName   size                     static bool     initialized   false                                                                                                             if   initialized                                                            for  size t index   0  index  lt  data     EnumName   size                        index                                                                                                                                        size t  length                                                              std  strcspn data     EnumName   raw names index                                     terminators                                                                                                                    the names index    new char length   1                                                                                                          std  strncpy the names index                                                         data     EnumName   raw names index                                     length                                                     the names index  length      0                                                                                                                                                                                      initialized   true                                                                                                                                                                                                  return the names                                                                                                                             and     The code above was a  header file   This is a program that uses it   include  lt iostream gt   include  the file above h   ENUM Channel  char  Red   1  Green  Blue   constexpr Channel   channel   Channel   from string  Red     int main         std  cout  lt  lt  channel  to string    lt  lt  std  endl       switch  channel            case Channel  Red    return 0          case Channel  Green  return 1          case Channel  Blue   return 2           static assert sizeof Channel     sizeof char          The program above prints Red  as you would expect  There is a degree of type safety  since you can t create an enum without initializing it  and deleting one of the cases from the switch will result in a warning from the compiler  depending on your compiler and flags   Also  note that  Red  was converted to an enum during compilation

User · Answer

I took the idea from  antron and implemented it differently  generating a true enum class    This implementation meets all the requirements listed in original question but currently has only one real limitation  it assumes the enum values are either not provided or  if provided  must start with 0 and go up sequentially without gaps    This is not an intrinsic limitation - simply that I don t use ad-hoc enum values  If this is needed  one can replace vector lookup with traditional switch case implementation    The solution uses some c  17 for inline variables but this can be easily avoided if needed  It also uses boost trim because of simplicity    Most importantly  it takes only 30 lines of code and no black magic macros  The code is below  It s meant to be put in header and included in multiple compilation modules   It can be used the same way as was suggested earlier in this thread   ENUM Channel  int  Red  Green   1  Blue  std  out  lt  lt   My name is    lt  lt  Channel  Green    prints My name is Green   Pls let me know if this is useful and how it can be improved further      include  lt boost algorithm string hpp gt     struct EnumSupportBase     static std  vector lt std  string gt  split const std  string s  char delim        std  stringstream ss s       std  string item      std  vector lt std  string gt  tokens      while  std  getline ss  item  delim             auto pos   item find first of                if  pos    std  string  npos              item erase  pos           boost  trim  item           tokens push back item             return tokens          define ENUM EnumName  Underlying             enum class EnumName   Underlying     VA ARGS     count          struct EnumName    Support   EnumSupportBase             static inline std  vector lt std  string gt   token names   split    VA ARGS                    static constexpr const char  get name EnumName enum value                  int index    int enum value                if  index  gt    int EnumName   count    index  lt  0                   return                      else                  return  token names index  c str                               inline std  ostream amp  operator lt  lt  std  ostream amp  os  const EnumName  amp  es              return os  lt  lt  EnumName  Support  get name es

User · Answer

Back in 2011 I spent a weekend fine-tuning a macro-based solution and ended up never using it   My current procedure is to start Vim  copy the enumerators in an empty switch body  start a new macro  transform the first enumerator into a case statement  move the cursor to the beginning of the next line  stop the macro and generate the remaining case statements by running the macro on the other enumerators    Vim macros are more fun than C   macros   Real-life example   enum class EtherType   uint16 t       ARP     0x0806      IPv4    0x0800      VLAN    0x8100      IPv6    0x86DD      I will create this   std  ostream amp  operator lt  lt   std  ostream amp  os  EtherType ethertype        switch  ethertype                case EtherType  ARP   return os  lt  lt   ARP            case EtherType  IPv4  return os  lt  lt   IPv4           case EtherType  VLAN  return os  lt  lt   VLAN           case EtherType  IPv6  return os  lt  lt   IPv6              omit default case to trigger compiler warning for missing cases            return os  lt  lt  static cast lt std  uint16 t gt  ethertype       And that s how I get by   Native support for enum stringification would be much better though  I m very interested to see the results of the reflection workgroup in C  17   An alternative way to do it was posted by  sehe in the comments

User · Answer

As long as you are okay with writing a separate  h  cpp pair for each queryable enum  this solution works with nearly the same syntax and capabilities as a regular c   enum      MyEnum h  include  lt EnumTraits h gt   ifndef ENUM INCLUDE MULTI  pragma once  end if  enum MyEnum   int ETRAITS       EDECL AAA    -8      EDECL BBB     8       EDECL CCC    AAA   BBB      The  cpp file is 3 lines of boilerplate      MyEnum cpp  define ENUM DEFINE MyEnum  define ENUM INCLUDE  lt MyEnum h gt   include  lt EnumTraits inl gt    Example usage   for  MyEnum value   EnumTraits lt MyEnum gt   GetValues        std  cout  lt  lt  EnumTraits lt MyEnum gt   GetName value   lt  lt  std  endl    Code  This solution requires 2 source files      EnumTraits h  pragma once  include  lt string gt   include  lt unordered map gt   include  lt vector gt    define ETRAITS  define EDECL x  x  template  lt class ENUM gt  class EnumTraits   public      static const std  vector lt ENUM gt  amp  GetValues                 return values             static ENUM GetValue const char  name                auto match   valueMap find name           return  match    valueMap end     ENUM     match- gt second              static const char  GetName ENUM value                auto match   nameMap find value           return  match    nameMap end     nullptr   match- gt second          public      EnumTraits     delete       using vector type   std  vector lt ENUM gt       using name map type   std  unordered map lt ENUM  const char  gt       using value map type   std  unordered map lt std  string  ENUM gt    private      static const vector type values      static const name map type nameMap      static const value map type valueMap      struct EnumInitGuard  constexpr const EnumInitGuard amp  operator  int  const   return  this       template  lt class T gt  constexpr T amp  operator lt  lt   T amp  amp  x  const EnumInitGuard amp     return x         and     EnumTraits inl  define ENUM INCLUDE MULTI   include ENUM INCLUDE  undef ETRAITS  undef EDECL  using EnumType   ENUM DEFINE  using TraitsType   EnumTraits lt EnumType gt   using VectorType   typename TraitsType  vector type  using NameMapType   typename TraitsType  name map type  using ValueMapType   typename TraitsType  value map type  using NamePairType   typename NameMapType  value type  using ValuePairType   typename ValueMapType  value type    define ETRAITS   const VectorType TraitsType  values  define EDECL x  EnumType  x  lt  lt   EnumInitGuard    include ENUM INCLUDE  undef ETRAITS  undef EDECL   define ETRAITS   const NameMapType TraitsType  nameMap  define EDECL x  NamePairType EnumType  x   x   lt  lt   EnumInitGuard    include ENUM INCLUDE  undef ETRAITS  undef EDECL   define ETRAITS   const ValueMapType TraitsType  valueMap  define EDECL x  ValuePairType  x  EnumType  x   lt  lt   EnumInitGuard    include ENUM INCLUDE  undef ETRAITS  undef EDECL   Explanation  This implementation exploits the fact that the braced list of elements of an enum definition can also be used as a braced initializer list for class member initialization   When ETRAITS is evaluated in the context of EnumTraits inl   it expands out to a static member definition for the EnumTraits lt  gt  class    The EDECL macro transforms each enum member into initializer list values which subsequently get passed into the member constructor in order to populate the enum info    The EnumInitGuard class is designed to consume the enum initializer values and then collapse - leaving a pure list of enum data   Benefits   c  -like syntax Works identically for both enum and enum class   almost  Works for enum types with any numeric underlying type Works for enum types with automatic  explicit  and fragmented initializer values Works for mass renaming  intellisense linking preserved  Only 5 preprocessor symbols  3 global      In contrast to enums  initializers in enum class types that reference other values from the same enum must have those values fully qualified  Disbenefits   Requires a separate  h  cpp pair for each queryable enum Depends on convoluted macro and include magic Minor syntax errors explode into much larger errors Defining class or namespace scoped enums is nontrivial No compile time initialization   Comments  Intellisense will complain a bit about private member access when opening up EnumTraits inl  but since the expanded macros are actually defining class members  that isn t actually a problem   The  ifndef ENUM INCLUDE MULTI block at the top of the header file is a minor annoyance that could probably be shrunken down into a macro or something  but it s small enough to live with at its current size   Declaring a namespace scoped enum requires that the enum first be forward declared inside its namespace scope  then defined in the global namespace  Additionally  any enum initializers using values of the same enum must have those values fully qualified   namespace ns   enum MyEnum   int    enum ns  MyEnum   int ETRAITS       EDECL AAA    -8      EDECL BBB     8       EDECL CCC    ns  MyEnum  AAA   ns  MyEnum  BBB

User · Answer

The following solution is based on a std  array lt std  string N gt  for a given enum   For enum to std  string conversion we can just cast the enum to size t and lookup the string from the array  The operation is O 1  and requires no heap allocation    include  lt boost preprocessor seq transform hpp gt   include  lt boost preprocessor seq enum hpp gt   include  lt boost preprocessor stringize hpp gt    include  lt string gt   include  lt array gt   include  lt iostream gt    define STRINGIZE s  data  elem  BOOST PP STRINGIZE elem      ENUM                                                                                  define ENUM X  SEQ    struct X           enum Enum  BOOST PP SEQ ENUM SEQ          static const std  array lt std  string BOOST PP SEQ SIZE SEQ  gt  array of strings               return   BOOST PP SEQ ENUM BOOST PP SEQ TRANSFORM STRINGIZE  0  SEQ                    static std  string to string Enum e              auto a   array of strings              return a static cast lt size t gt  e                  For std  string to enum conversion we would have to make a linear search over the array and cast the array index to enum   Try it here with usage examples  http   coliru stacked-crooked com a e4212f93bee65076  Edit  Reworked my solution so the custom Enum can be used inside a class

User · Answer

This gist provides a simple mapping based on C   variadic templates   This is a C  17-simplified version of the type-based map from the gist    include  lt cstring gt     http   stackoverflow com q 24520781  template lt typename KeyValue  typename     RestOfKeyValues gt  struct map     static constexpr typename KeyValue  key t get const char  val  noexcept       if constexpr  sizeof    RestOfKeyValues   0      C  17 if constexpr       return KeyValue  key     Returns last element     else         static assert KeyValue  val    nullptr                     Only last element may have null name          return strcmp val  KeyValue  val                   map lt RestOfKeyValues    gt   get val    KeyValue  key              static constexpr const char  get typename KeyValue  key t key  noexcept       if constexpr  sizeof    RestOfKeyValues   0        return  KeyValue  val    nullptr   amp  amp   key    KeyValue  key                KeyValue  val             else       return  key    KeyValue  key                 KeyValue  val     map lt RestOfKeyValues    gt   get key           template lt typename Enum  typename     KeyValues gt  class names     typedef map lt KeyValues    gt  Map  public    static constexpr Enum get const char  nam  noexcept       return Map  get nam         static constexpr const char  get Enum key  noexcept       return Map  get key            An example usage    enum class fasion       fancy      classic      sporty      emo        last     emo        unknown     -1      define NAME s  static inline constexpr const char  s   noexcept  return  s   namespace name       NAME fancy      NAME classic      NAME sporty      NAME emo     template lt auto K  const char    V    gt      C  17 template lt auto gt  struct         typedef decltype K  key t      typedef decltype V  name t      static constexpr key t  key   K     enum id value     static constexpr name t val   V     enum id name     typedef names lt fasion        lt fasion  fancy  name  fancy gt         lt fasion  classic  name  classic gt         lt fasion  sporty  name  sporty gt         lt fasion  emo  name  emo gt         lt fasion    unknown    nullptr gt   gt  fasion names    The map lt KeyValues    gt  can be used in both directions    fasion names  get fasion  emo  fasion names  get  emo     This example is available on godbolt org  int main        constexpr auto str   fasion names  get fasion  emo     constexpr auto fsn   fasion names  get str     return  int  fsn      Result from gcc-7 -std c  1z -Ofast -S  main          mov     eax  3         ret

[c++] enum to string in modern C++11 / C++14 / C++17 and future C++20

Examples related to c++

Examples related to string

Examples related to enums

Examples related to c++17

Examples related to c++20