How to automatically convert strongly typed enum into int

Question

include  lt iostream gt   struct a     enum LOCAL A   A1  A2       enum class b   B1  B2     int foo int input    return input     int main void      std  cout  lt  lt  foo a  A1   lt  lt  std  endl    std  cout  lt  lt  foo static cast lt int gt  b  B2    lt  lt  std  endl      The a  LOCAL A is what the strongly typed enum is trying to achieve  but there is a small difference   normal enums can be converted into integer type  while strongly typed enums can not do it without a cast   So  is there a way to convert a strongly typed enum value into an integer type without a cast  If yes  how

User · Answer

As many said  there is no way to automatically convert without adding overheads and too much complexity  but you can reduce your typing a bit and make it look better by using lambdas if some cast will be used a bit much in a scenario  That would add a bit of function overhead call  but will make code more readable compared to long static cast strings as can be seen below  This may not be useful project wide  but only class wide    include  lt bitset gt   include  lt vector gt   enum class Flags           Total    std  bitset lt static cast lt unsigned int gt  Total  gt  MaskVar  std  vector lt Flags gt  NewFlags   ----------- auto scui      Flags a  return static cast lt unsigned int gt  a       for  auto const amp  it   NewFlags        switch  it            case Flags  Horizontal          MaskVar set scui Flags  Horizontal            MaskVar reset scui Flags  Vertical    break      case Flags  Vertical          MaskVar set scui Flags  Vertical            MaskVar reset scui Flags  Horizontal    break      case Flags  LongText          MaskVar set scui Flags  LongText            MaskVar reset scui Flags  ShorTText    break      case Flags  ShorTText          MaskVar set scui Flags  ShorTText            MaskVar reset scui Flags  LongText    break       case Flags  ShowHeading          MaskVar set scui Flags  ShowHeading            MaskVar reset scui Flags  NoShowHeading    break      case Flags  NoShowHeading          MaskVar set scui Flags  NoShowHeading            MaskVar reset scui Flags  ShowHeading    break       default          break

User · Answer

TLDR   There are no implicit conversions from the values of a scoped enumerator  AKA   quot strong enum quot   to integral types  although static cast may be used to obtain the numeric value of the enumerator    emphasis added  Source  https   en cppreference com w cpp language enum -- gt  under the section  quot Scoped enumerations quot   Going further In C   there are two types of enums    quot regular quot    quot weak quot    quot weakly typed quot   or  quot C-style quot  enums  and  quot scoped quot    quot strong quot    quot strongly typed quot    quot enum class quot   or  quot C  -style quot  enums    quot Scoped quot  enums  or  quot strong quot  enums  give two additional  quot features quot  beyond what  quot regular quot  enums give you  Scoped enums   don t allow implicit casting from the enum type to an integer type  so you can t do what you want to do implicitly    and they  quot scope quot  the enum so that you have to access the enum through its enum type name   Example of an enum class     enum class  AKA   quot strong quot  or  quot scoped quot  enum  enum class my enum       A   0      B      C      my enum e   my enum  A     scoped through  my enum    e   my enum  B      NOT ALLOWED        error  cannot convert    my enum    to    int    in initialization    int i   e       But this works fine  int i   static cast lt int gt  e    The first  quot feature quot  may actually be something you don t want  in which case you just need to use a regular C-style enum instead  And the nice thing is  you can still  quot scope quot  or  quot namespace quot  the enum  as has been done in C for decades  by simply prepending its name with the enum type name  like this  Example of a regular enum     regular enum  AKA   quot weak quot  or  quot C-style quot  enum  enum my enum       MY ENUM A   0      MY ENUM B      MY ENUM C      my enum e   MY ENUM A     scoped through  MY ENUM   e   MY ENUM B      This works fine  int i   e   Notice you still get the benefit of  quot scoping quot  simply by adding the MY ENUM   quot scope quot  to the front of each enum   Test the above code here  https   onlinegdb com SJQ7uthcP

User · Answer

Short answer is you can t as above posts point out  But for my case  I simply didn t want to clutter the namespace but still have implicit conversions  so I just did    include  lt iostream gt   using namespace std   namespace Foo      enum Foo   bar  baz       int main        cout  lt  lt  Foo  bar  lt  lt  endl     0    cout  lt  lt  Foo  baz  lt  lt  endl     1    return 0      The namespacing sort of adds a layer of type-safety while I don t have to static cast any enum values to the underlying type

User · Answer

A C  14 version of the answer provided by R  Martinho Fernandes would be    include  lt type traits gt   template  lt typename E gt  constexpr auto to underlying E e  noexcept       return static cast lt std  underlying type t lt E gt  gt  e       As with the previous answer  this will work with any kind of enum and underlying type   I have added the noexcept keyword as it will never throw an exception     Update This also appears in Effective Modern C   by Scott Meyers   See item 10  it is detailed in the final pages of the item within my copy of the book

User · Answer

Hope this helps you or someone else  enum class EnumClass   int   set size for enum       Zero  One  Two  Three  Four     union Union   This will allow us to convert       EnumClass ec      int i      int main     using namespace std     convert from strongly typed enum to int  Union un2  un2 ec   EnumClass  Three   cout  lt  lt   un2 i      lt  lt  un2 i  lt  lt  endl     convert from int to strongly typed enum Union un  un i   0    if un ec    EnumClass  Zero  cout  lt  lt   True   lt  lt  endl   return 0

User · Answer

As others have said  you can t have an implicit conversion  and that s by-design   If you want you can avoid the need to specify the underlying type in the cast   template  lt typename E gt  constexpr typename std  underlying type lt E gt   type to underlying E e  noexcept       return static cast lt typename std  underlying type lt E gt   type gt  e      std  cout  lt  lt  foo to underlying b  B2    lt  lt  std  endl

User · Answer

include  lt cstdlib gt   include  lt cstdio gt   include  lt cstdint gt    include  lt type traits gt   namespace utils    namespace details    template lt  typename E  gt  using enable enum t   typename std  enable if lt  std  is enum lt E gt   value                                                  typename std  underlying type lt E gt   type                                                gt   type          namespace details   template lt  typename E  gt  constexpr inline details  enable enum t lt E gt  underlying value  E e  noexcept       return static cast lt  typename std  underlying type lt E gt   type  gt   e           template lt  typename E   typename T gt  constexpr inline typename std  enable if lt  std  is enum lt E gt   value  amp  amp                                            std  is integral lt T gt   value  E                                           gt   type   to enum  T value   noexcept          return static cast lt E gt   value             namespace utils     int main         enum class E  a   1  b   3  c   5         constexpr auto a   utils  underlying value E  a       constexpr E    b   utils  to enum lt E gt  5       constexpr auto bv   utils  underlying value b        printf  a    d  b    d   a bv       return 0

User · Answer

This seems impossible with the native enum class  but probably you can mock a enum class with a class   In this case   enum class b       B1      B2      would be equivalent to   class b    private    int underlying   public    static constexpr int B1   0    static constexpr int B2   1    b int v    underlying v       operator int           return underlying           This is mostly equivalent to the original enum class  You can directly return b  B1 for in a function with return type b  You can do switch case with it  etc   And in the spirit of this example you can use templates  possibly together with other things  to generalize and mock any possible object defined by the enum class syntax

User · Answer

The reason for the absence of implicit conversion  by design  was given in other answers   I personally use unary operator  for the conversion from enum classes to their underlying type   template  lt typename T gt  constexpr auto operator  T e  noexcept     - gt  std  enable if t lt std  is enum lt T gt   value  std  underlying type t lt T gt  gt        return static cast lt std  underlying type t lt T gt  gt  e       Which gives quite little  typing overhead    std  cout  lt  lt  foo  b  B2   lt  lt  std  endl    Where I actually use a macro to create enums and the operator functions in one shot    define UNSIGNED ENUM CLASS name       enum class name   unsigned     VA ARGS       inline constexpr unsigned operator   name const val    return static cast lt unsigned gt  val

User · Answer

The C   committee took one step forward  scoping enums out of global namespace  and fifty steps back  no enum type decay to integer    Sadly  enum class is simply not usable if you need the value of the enum in any non-symbolic way  The best solution is to not use it at all  and instead scope the enum yourself using a namespace or a struct   For this purpose  they are interchangable   You will need to type a little extra when refering to the enum type itself  but that will likely not be often  struct TextureUploadFormat       enum Type   uint32           r          rg          rgb          rgba            count               must use   Type  which is the extra typing with this method  beats all the static cast lt  gt    uint32 getFormatStride TextureUploadFormat  Type format       const uint32 formatStride TextureUploadFormat    count              1          2          3          4            return formatStride format      decays without complaint

User · Answer

An extension to the answers from R  Martinho Fernandes and Class Skeleton  Their answers show how to use typename std  underlying type lt EnumType gt   type or std  underlying type t lt EnumType gt  to convert your enumeration value with a static cast to a value of the underlying type   Compared to a static cast to some specific integer type  like  static cast lt int gt  this has the benefit of being maintenance friendly  because when the underlying type changes  the code using std  underlying type t will automatically use the new type  This  however  is sometimes not what you want  Assume you wanted to print out enumeration values directly  for example to std  cout  like in the following example  enum class EnumType   int   Green  Blue  Yellow    std  cout  lt  lt  static cast lt std  underlying type t lt EnumType gt  gt  EnumType  Green    If you later change the underlying type to a character type  like  uint8 t  then the value of EnumType  Green will not be printed as a number  but as a character  which is most probably not what you want   Thus  you sometimes would rather convert the enumeration value into something like  quot underlying type  but with integer promotion where necessary quot   It would be possible to apply the unary operator  to the result of the cast to force integer promotion if necessary   However  you can also use std  common type t  also from header file  lt type traits gt   to do the following  enum class EnumType   int   Green  Blue  Yellow    std  cout  lt  lt  static cast lt std  common type t lt int  std  underlying type t lt EnumType gt  gt  gt  EnumType  Green    Preferrably you would wrap this expression in some helper template function  template  lt class E gt  constexpr std  common type t lt int  std  underlying type t lt E gt  gt  enumToInteger E e        return static cast lt std  common type t lt int  std  underlying type t lt E gt  gt  gt  e      Which would then be more friendly to the eyes  be maintenance friendly with respect to changes to the underlying type  and without need for tricks with operator   std  cout  lt  lt  enumToInteger EnumType  Green

User · Answer

Strongly typed enums aiming to solve multiple problems and not only scoping problem as you mentioned in your question    Provide type safety  thus eliminating implicit conversion to integer by integral promotion  Specify underlying types  Provide strong scoping    Thus  it is impossible to implicitly convert a strongly typed enum to integers  or even its underlying type - that s the idea  So you have to use static cast to make conversion explicit   If your only problem is scoping and you really want to have implicit promotion to integers  then you better off using not strongly typed enum with the scope of the structure it is declared in

User · Answer

No  There is no natural way   In fact  one of the motivations behind having strongly typed enum class in C  11 is to prevent their silent conversion to int

[c++] How to automatically convert strongly typed enum into int?

Examples related to c++

Examples related to c++11

Examples related to strongly-typed-enum