How to use enums as flags in C

Question

Treating enums as flags works nicely in C  via the  Flags  attribute  but what s the best way to do this in C     For example  I d like to write   enum AnimalFlags       HasClaws   1      CanFly  2      EatsFish   4      Endangered   8     seahawk flags   CanFly   EatsFish   Endangered    However  I get compiler errors regarding int enum conversions   Is there a nicer way to express this than just blunt casting   Preferably  I don t want to rely on constructs from 3rd party libraries such as boost or Qt   EDIT  As indicated in the answers  I can avoid the compiler error by declaring seahawk flags as int   However  I d like to have some mechanism to enforce type safety  so someone can t write seahawk flags   HasMaximizeButton

User · Accepted Answer

The  correct  way is to define bit operators for the enum  as   enum AnimalFlags       HasClaws     1      CanFly       2      EatsFish     4      Endangered   8     inline AnimalFlags operator  AnimalFlags a  AnimalFlags b        return static cast lt AnimalFlags gt  static cast lt int gt  a    static cast lt int gt  b        Etc  rest of the bit operators  Modify as needed if the enum range exceeds int range

User · Answer

I use the following macro    define ENUM FLAG OPERATORS T                                                                                                                                                   inline T operator   T a    return static cast lt T gt    static cast lt std  underlying type lt T gt   type gt  a                                                                                   inline T operator   T a  T b    return static cast lt T gt   static cast lt std  underlying type lt T gt   type gt  a    static cast lt std  underlying type lt T gt   type gt  b                               inline T operator amp   T a  T b    return static cast lt T gt   static cast lt std  underlying type lt T gt   type gt  a   amp  static cast lt std  underlying type lt T gt   type gt  b                               inline T operator   T a  T b    return static cast lt T gt   static cast lt std  underlying type lt T gt   type gt  a    static cast lt std  underlying type lt T gt   type gt  b                               inline T amp  operator    T amp  a  T b    return reinterpret cast lt T amp  gt   reinterpret cast lt std  underlying type lt T gt   type amp  gt  a     static cast lt std  underlying type lt T gt   type gt  b               inline T amp  operator amp    T amp  a  T b    return reinterpret cast lt T amp  gt   reinterpret cast lt std  underlying type lt T gt   type amp  gt  a   amp   static cast lt std  underlying type lt T gt   type gt  b               inline T amp  operator    T amp  a  T b    return reinterpret cast lt T amp  gt   reinterpret cast lt std  underlying type lt T gt   type amp  gt  a     static cast lt std  underlying type lt T gt   type gt  b         It is similar to the ones mentioned above but has several improvements     It is type safe  it does not suppose that the underlying type is an int  It does not require to specify manually the underlying type  as opposed to  LunarEclipse  s answer    It does need to include type traits    include  lt type traits gt

User · Answer

What type is the seahawk flags variable   In standard C    enumerations are not type-safe  They are effectively integers   AnimalFlags should NOT be the type of your variable   Your variable should be int and the error will go away   Putting hexadecimal values like some other people suggested is not needed   It makes no difference   The enum values ARE of type int by default   So you can surely bitwise OR combine them and put them together and store the result in an int     The enum type is a restricted subset of int whose value is one of its enumerated values   Hence  when you make some new value outside of that range  you can t assign it without casting to a variable of your enum type   You can also change the enum value types if you d like  but there is no point for this question    EDIT  The poster said they were concerned with type safety and they don t want a value that should not exist inside the int type   But it would be type unsafe to put a value outside of AnimalFlags s range inside a variable of type AnimalFlags    There is a safe way to check for out of range values though inside the int type     int iFlags   HasClaws   CanFly    InvalidAnimalFlagMaxValue-1 gives you a value of all the bits     smaller than itself set to 1   This check makes sure that no other bits are set  assert iFlags  amp    InvalidAnimalFlagMaxValue-1     0    enum AnimalFlags       HasClaws   1      CanFly  2      EatsFish   4      Endangered   8          put new enum values above here     InvalidAnimalFlagMaxValue   16      The above doesn t stop you from putting an invalid flag from a different enum that has the value 1 2 4  or 8 though   If you want absolute type safety then you could simply create a std  set and store each flag inside there   It is not space efficient  but it is type safe and gives you the same ability as a bitflag int does   C  0x note  Strongly typed enums  In C  0x you can finally have type safe enum values      enum class AnimalFlags       CanFly   2      HasClaws   4     if CanFly    2       Compiling error

User · Answer

Currently there is no language support for enum flags  Meta classes might inherently add this feature if it would ever be part of the c   standard   My solution would be to create enum-only instantiated template functions adding support for type-safe bitwise operations for enum class using its underlying type   File  EnumClassBitwise h   pragma once  ifndef  ENUM CLASS BITWISE H   define  ENUM CLASS BITWISE H    include  lt type traits gt     unary  operator     template  lt typename Enum  typename std  enable if t lt std  is enum lt Enum gt   value  int gt    0 gt  constexpr inline Enum amp  operator   Enum amp  val        val   static cast lt Enum gt   static cast lt std  underlying type t lt Enum gt  gt  val        return val         amp  operator template  lt typename Enum  typename std  enable if t lt std  is enum lt Enum gt   value  int gt    0 gt  constexpr inline Enum operator amp   Enum lhs  Enum rhs        return static cast lt Enum gt  static cast lt std  underlying type t lt Enum gt  gt  lhs   amp  static cast lt std  underlying type t lt Enum gt  gt  rhs           amp   operator template  lt typename Enum  typename std  enable if t lt std  is enum lt Enum gt   value  int gt    0 gt  constexpr inline Enum operator amp    Enum amp  lhs  Enum rhs        lhs   static cast lt Enum gt  static cast lt std  underlying type t lt Enum gt  gt  lhs   amp  static cast lt std  underlying type t lt Enum gt  gt  rhs        return lhs         operator  template  lt typename Enum  typename std  enable if t lt std  is enum lt Enum gt   value  int gt    0 gt  constexpr inline Enum operator   Enum lhs  Enum rhs        return static cast lt Enum gt  static cast lt std  underlying type t lt Enum gt  gt  lhs    static cast lt std  underlying type t lt Enum gt  gt  rhs           operator  template  lt typename Enum  typename std  enable if t lt std  is enum lt Enum gt   value  int gt    0 gt  constexpr inline Enum amp  operator    Enum amp  lhs  Enum rhs        lhs   static cast lt Enum gt  static cast lt std  underlying type t lt Enum gt  gt  lhs    static cast lt std  underlying type t lt Enum gt  gt  rhs        return lhs      endif     ENUM CLASS BITWISE H    For convenience and for reducing mistakes  you might want to wrap your bit flags operations for enums and for integers as well   File  BitFlags h   pragma once  ifndef  BIT FLAGS H   define  BIT FLAGS H    include  EnumClassBitwise h    template lt typename T gt   class BitFlags     public        constexpr inline BitFlags     default       constexpr inline BitFlags T value    mValue   value         constexpr inline BitFlags operator   T rhs  const   return mValue   rhs         constexpr inline BitFlags operator amp   T rhs  const   return mValue  amp  rhs         constexpr inline BitFlags operator     const   return  mValue         constexpr inline operator T   const   return mValue         constexpr inline BitFlags amp  operator   T rhs    mValue    rhs  return  this         constexpr inline BitFlags amp  operator amp   T rhs    mValue  amp   rhs  return  this         constexpr inline bool test T rhs  const   return  mValue  amp  rhs     rhs         constexpr inline void set T rhs    mValue    rhs         constexpr inline void clear T rhs    mValue  amp    rhs      private       T mValue       endif    define  BIT FLAGS H    Possible usage    include  lt cstdint gt   include  lt BitFlags h gt  void main         enum class Options   uint32 t                  NoOption   0  lt  lt  0           Option1    1  lt  lt  0           Option2    1  lt  lt  1           Option3    1  lt  lt  2           Option4    1  lt  lt  3             const uint32 t Option1   1  lt  lt  0      const uint32 t Option2   1  lt  lt  1      const uint32 t Option3   1  lt  lt  2      const uint32 t Option4   1  lt  lt  3        Enum BitFlags     BitFlags lt Options gt  optionsEnum Options  NoOption       optionsEnum set Options  Option1   Options  Option3         Standard integer BitFlags     BitFlags lt uint32 t gt  optionsUint32 0       optionsUint32 set Option1   Option3         return 0

User · Answer

Xaqq has provided a really nice type-safe way to use enum flags here by a flag set class   I published the code in GitHub  usage is as follows    include  flag set hpp   enum class AnimalFlags   uint8 t       HAS CLAWS      CAN FLY      EATS FISH      ENDANGERED            int main         flag set lt AnimalFlags gt  seahawkFlags AnimalFlags  HAS CLAWS                                          AnimalFlags  EATS FISH                                          AnimalFlags  ENDANGERED        if  seahawkFlags  amp  AnimalFlags  ENDANGERED          cout  lt  lt   Seahawk is endangered

User · Answer

I found myself asking the same question and came up with a generic C  11 based solution  similar to soru s   template  lt typename TENUM gt  class FlagSet    private      using TUNDER   typename std  underlying type lt TENUM gt   type      std  bitset lt std  numeric limits lt TUNDER gt   max   gt  m flags   public      FlagSet     default       template  lt typename    ARGS gt      FlagSet TENUM f  ARGS    args    FlagSet args                      set f                FlagSet amp  set TENUM f                   m flags set static cast lt TUNDER gt  f            return  this               bool test TENUM f                   return m flags test static cast lt TUNDER gt  f                 FlagSet amp  operator   TENUM f                   return set f                 The interface can be improved to taste  Then it can be used like so   FlagSet lt Flags gt  flags Flags  FLAG A  Flags  FLAG C   flags    Flags  FLAG D

User · Answer

I d like to elaborate on Uliwitness answer  fixing his code for C  98 and using the Safe Bool idiom  for lack of the std  underlying type lt  gt  template and the explicit keyword in C   versions below C  11   I also modified it so that the enum values can be sequential without any explicit assignment  so you can have  enum AnimalFlags        HasClaws      CanFly      EatsFish      Endangered    typedef FlagsEnum lt AnimalFlags  gt  AnimalFlags   seahawk flags   AnimalFlags     CanFly   EatsFish   Endangered    You can then get the raw flags value with  seahawk flags value      Here s the code   template  lt typename EnumType  typename Underlying   int gt  class FlagsEnum       typedef Underlying FlagsEnum    RestrictedBool   public      FlagsEnum     m flags Underlying            FlagsEnum EnumType singleFlag           m flags 1  lt  lt  singleFlag              FlagsEnum const FlagsEnum amp  original           m flags original m flags              FlagsEnum amp  operator    const FlagsEnum amp  f            m flags    f m flags          return  this             FlagsEnum amp  operator  amp   const FlagsEnum amp  f            m flags  amp   f m flags          return  this             friend FlagsEnum operator   const FlagsEnum amp  f1  const FlagsEnum amp  f2            return FlagsEnum f1     f2             friend FlagsEnum operator  amp  const FlagsEnum amp  f1  const FlagsEnum amp  f2            return FlagsEnum f1   amp   f2             FlagsEnum operator     const           FlagsEnum result  this           result m flags    result m flags          return result             operator RestrictedBool   const           return m flags    amp FlagsEnum  m flags   0             Underlying value   const           return m flags         protected      Underlying  m flags

User · Answer

Another macro solution  but unlike the existing answers this does not use reinterpret cast  or a C-cast  to cast between Enum amp  and Int amp   which is forbidden in standard C    see this post    define MAKE FLAGS ENUM TEnum  TUnder                                                                                                TEnum  operator     TEnum  a              return static cast lt TEnum gt    static cast lt TUnder gt   a                                    TEnum  operator     TEnum  a  TEnum b     return static cast lt TEnum gt    static cast lt TUnder gt   a     static cast lt TUnder gt  b          TEnum  operator amp     TEnum  a  TEnum b     return static cast lt TEnum gt    static cast lt TUnder gt   a   amp   static cast lt TUnder gt  b          TEnum  operator     TEnum  a  TEnum b     return static cast lt TEnum gt    static cast lt TUnder gt   a     static cast lt TUnder gt  b          TEnum amp  operator     TEnum amp  a  TEnum b     a   static cast lt TEnum gt  static cast lt TUnder gt  a    static cast lt TUnder gt  b     return a       TEnum amp  operator amp     TEnum amp  a  TEnum b     a   static cast lt TEnum gt  static cast lt TUnder gt  a   amp  static cast lt TUnder gt  b     return a       TEnum amp  operator     TEnum amp  a  TEnum b     a   static cast lt TEnum gt  static cast lt TUnder gt  a    static cast lt TUnder gt  b     return a     Losing the reinterpret cast means we can t rely on the x    y syntax any more  but by expanding these into their x   x   y forms we no longer need it  Note  You can use std  underlying type to obtain TUnder  I ve not included it for brevity

User · Answer

As above Kai  or do the following  Really enums are  Enumerations   what you want to do is have a set  therefore you should really use stl  set  enum AnimalFlags       HasClaws   1      CanFly  2      EatsFish   4      Endangered   8     int main void        AnimalFlags seahawk        seahawk  CanFly   EatsFish   Endangered      seahawk  static cast lt AnimalFlags gt  CanFly   EatsFish   Endangered

User · Answer

If your compiler doesn t support strongly typed enums yet  you can give a look to the following article from the c   source   From the abstract      This article presents a solution to the problem of constraining bit operations to       allow only safe and legitimate ones  and turn all invalid bit manipulations into       compile-time errors  Best of all  the syntax of bit operations remains unchanged         and the code working with bits does not need to be modified  except possibly to        fix errors that had as yet remained undetected

User · Answer

Here is my solution without needing any bunch of overloading or casting   namespace EFoobar       enum               FB A      0x1          FB B      0x2          FB C      0x4             typedef long Flags     void Foobar EFoobar  Flags flags        if  flags  amp  EFoobar  FB A             do sth               if  flags  amp  EFoobar  FB B             do sth              void ExampleUsage         Foobar EFoobar  FB A   EFoobar  FB B       EFoobar  Flags otherflags   0      otherflags   EFoobar  FB B      otherflags amp    EFoobar  FB B      Foobar otherflags       I think it s ok  because we identify  non strongly typed  enums and ints anyway   Just as a  longer  side note  if you   want to use strongly typed enums and don t need heavy bit fiddling with your flags performance is not an issue   I would come up with this    include  lt set gt   enum class EFoobarFlags       FB A   1      FB B      FB C      void Foobar const std  set lt EFoobarFlags gt  amp  flags        if  flags find EFoobarFlags  FB A     flags end               do sth               if  flags find EFoobarFlags  FB B     flags end               do sth              void ExampleUsage         Foobar  EFoobarFlags  FB A  EFoobarFlags  FB B        std  set lt EFoobarFlags gt  otherflags        otherflags insert EFoobarFlags  FB B       otherflags erase EFoobarFlags  FB B       Foobar otherflags       using C  11 initializer lists and enum class

User · Answer

Only syntactic sugar  No additional metadata    namespace UserRole    grupy        constexpr uint8 t dea   1      constexpr uint8 t red   2      constexpr uint8 t stu   4      constexpr uint8 t kie   8      constexpr uint8 t adm   16      constexpr uint8 t mas   32      Flag operators on integral type just works

User · Answer

You are confusing objects and collections of objects  Specifically  you are confusing binary flags with sets of binary flags  A proper solution would look like this      These are individual flags enum AnimalFlag    Flag  not Flags       HasClaws   0      CanFly      EatsFish      Endangered     class AnimalFlagSet       int m Flags     public       AnimalFlagSet     m Flags 0           void Set  AnimalFlag flag     m Flags     1  lt  lt  flag          void Clear  AnimalFlag flag     m Flags  amp      1  lt  lt  flag          bool Get  AnimalFlag flag   const   return  m Flags  gt  gt  flag   amp  1

User · Answer

Here s an option for bitmasks if you don t actually have a use for the individual enum values  ex  you don t need to switch off of them     and if you aren t worried about maintaining binary compatibility ie  you don t care where your bits live    which you probably are  Also you d better not be too concerned with scoping and access control  Hmmm  enums have some nice properties for bit-fields    wonder if anyone has ever tried that     struct AnimalProperties       bool HasClaws   1      bool CanFly   1      bool EatsFish   1      bool Endangered   1      union AnimalDescription       AnimalProperties Properties      int Flags      void TestUnionFlags         AnimalDescription propertiesA      propertiesA Properties CanFly   true       AnimalDescription propertiesB   propertiesA      propertiesB Properties EatsFish   true       if  propertiesA Flags    propertiesB Flags                 cout  lt  lt   Life is terrible                else               cout  lt  lt   Life is great               AnimalDescription propertiesC   propertiesA      if  propertiesA Flags    propertiesC Flags                 cout  lt  lt   Life is great              else               cout  lt  lt   Life is terrible                We can see that life is great  we have our discrete values  and we have a nice int to  amp  and   to our hearts content  which still has context of what its bits mean  Everything is consistent and predictable    for me    as long as I keep using Microsoft s VC   compiler w  Update 3 on Win10 x64 and don t touch my compiler flags     Even though everything is great    we have some context as to the meaning of flags now  since its in a union w  the bitfield in the terrible real world where your program may be be responsible for more than a single discrete task you could still accidentally  quite easily  smash two flags fields of different unions together  say  AnimalProperties and ObjectProperties  since they re both ints   mixing up all yours bits  which is a horrible bug to trace down    and how I know many people on this post don t work with bitmasks very often  since building them is easy and maintaining them is hard    class AnimalDefinition   public      static AnimalDefinition  GetAnimalDefinition  AnimalFlags flags        A little too obvious for my taste    NEXT      static AnimalDefinition  GetAnimalDefinition  AnimalProperties properties        Oh I see how to use this  BORING  NEXT      static AnimalDefinition  GetAnimalDefinition  int flags      hmm  wish I could see how to construct a valid  flags  int without CrossFingers Ctrl Shift F  Animal     Maybe just hard-code 16 or something       AnimalFlags animalFlags     Well this is  way  too hard to break unintentionally  screw this      int flags    PERFECT  Nothing will ever go wrong here           wait  what values are used for this particular flags field  Is this AnimalFlags or ObjectFlags  Or is it RuntimePlatformFlags  Does it matter  Where s the documentation         Well luckily anyone in the code base and get confused and destroy the whole program  At least I don t need to static cast anymore  phew       private      AnimalDescription m description    Oh I know what this is  All of the mystery and excitement of life has been stolen away        So then you make your union declaration private to prevent direct access to  Flags   and have to add getters setters and operator overloads  then make a macro for all that  and you re basically right back where you started when you tried to do this with an Enum   Unfortunately if you want your code to be portable  I don t think there is any way to either A  guarantee the bit layout or B  determine the bit layout at compile time  so you can track it and at least correct for changes across versions platforms etc  Offset in a struct with bit fields  At runtime you can play tricks w  setting the the fields and XORing the flags to see which bits did change  sounds pretty crappy to me though verses having a 100  consistent  platform independent  and completely deterministic solution ie  an ENUM   TL DR  Don t listen to the haters  C   is not English  Just because the literal definition of an abbreviated keyword inherited from C might not fit your usage doesn t mean you shouldn t use it when the C and C   definition of the keyword absolutely includes your use case  You can also use structs to model things other than structures  and classes for things other than school and social caste  You may use float for values which are grounded  You may use char for variables which are neither un-burnt nor a person in a novel  play  or movie  Any programmer who goes to the dictionary to determine the meaning of a keyword before the language spec is a    well I ll hold my tongue there    If you do want your code modeled after spoken language you d be best off writing in Objective-C  which incidentally also uses enums heavily for bitfields

User · Answer

Easiest way to do this as shown here  using the standard library class bitset   To emulate the C  feature in a type-safe way  you d have to write a template wrapper around the bitset  replacing the int arguments with an enum given as a type parameter to the template  Something like       template  lt class T  int N gt  class FlagSet        bitset lt N gt  bits       FlagSet T enumVal                bits set enumVal                 etc      enum MyFlags       FLAG ONE      FLAG TWO     FlagSet lt MyFlags  2 gt  myFlag

User · Answer

For lazy people like me  here is templated solution to copy amp paste   template lt class T gt  inline T operator   T a    return  T   int a    template lt class T gt  inline T operator   T a  T b    return  T   int a    int b     template lt class T gt  inline T operator amp   T a  T b    return  T   int a  amp   int b     template lt class T gt  inline T operator   T a  T b    return  T   int a    int b     template lt class T gt  inline T amp  operator    T amp  a  T b    return  T amp    int amp  a     int b     template lt class T gt  inline T amp  operator amp    T amp  a  T b    return  T amp    int amp  a  amp    int b     template lt class T gt  inline T amp  operator    T amp  a  T b    return  T amp    int amp  a     int b

User · Answer

The C   standard explicitly talks about this  see section  17 5 2 1 3 Bitmask types    http   www open-std org jtc1 sc22 wg21 docs papers 2012 n3485 pdf  Given this  template  you get   enum AnimalFlags   unsigned int       HasClaws   1      CanFly   2      EatsFish   4      Endangered   8     constexpr AnimalFlags operator  AnimalFlags X  AnimalFlags Y        return static cast lt AnimalFlags gt           static cast lt unsigned int gt  X    static cast lt unsigned int gt  Y       AnimalFlags amp  operator   AnimalFlags amp  X  AnimalFlags Y        X   X   Y  return X      And similar for the other operators  Also note the  constexpr   it is needed if you want the compiler to be able to execute the operators compile time   If you are using C   CLI and want to able assign to enum members of ref classes you need to use tracking references instead   AnimalFlags  operator   AnimalFlags  X  AnimalFlags Y        X   X   Y  return X      NOTE  This sample is not complete  see section  17 5 2 1 3 Bitmask types  for a complete set of operators

User · Answer

I find the currently accepted answer by eidolon too dangerous  The compiler s optimizer might make assumptions about possible values in the enum and you might get garbage back with invalid values  And usually nobody wants to define all possible permutations in flags enums   As Brian R  Bondy states below  if you re using C  11  which everyone should  it s that good  you can now do this more easily with enum class   enum class ObjectType   uint32 t       ANIMAL    1  lt  lt  0       VEGETABLE    1  lt  lt  1       MINERAL    1  lt  lt  2       constexpr enum ObjectType operator    const enum ObjectType selfValue  const enum ObjectType inValue         return  enum ObjectType  uint32 t selfValue    uint32 t inValue              add more operators here     This ensures a stable size and value range by specifying a type for the enum  inhibits automatic downcasting of enums to ints etc  by using enum class  and uses constexpr to ensure the code for the operators gets inlined and thus just as fast as regular numbers   For people stuck with pre-11 C   dialects  If I was stuck with a compiler that doesn t support C  11  I d go with wrapping an int-type in a class that then permits only use of bitwise operators and the types from that enum to set its values   template lt class ENUM class UNDERLYING typename std  underlying type lt ENUM gt   type gt  class SafeEnum   public      SafeEnum     mFlags 0         SafeEnum  ENUM singleFlag     mFlags singleFlag         SafeEnum  const SafeEnum amp  original     mFlags original mFlags          SafeEnum amp    operator     ENUM addValue        mFlags    addValue  return  this        SafeEnum    operator    ENUM addValue         SafeEnum  result  this   result    addValue  return result        SafeEnum amp    operator  amp    ENUM maskValue       mFlags  amp   maskValue  return  this        SafeEnum    operator  amp   ENUM maskValue        SafeEnum  result  this   result  amp   maskValue  return result        SafeEnum    operator          SafeEnum  result  this   result mFlags    result mFlags  return result        explicit operator bool                        return mFlags    0     protected      UNDERLYING  mFlags       You can define this pretty much like a regular enum   typedef   enum TFlags        EFlagsNone    0      EFlagOne       1  lt  lt  0       EFlagTwo       1  lt  lt  1       EFlagThree     1  lt  lt  2       EFlagFour      1  lt  lt  3      typedef SafeEnum lt enum TFlags  gt   TFlags    And usage is similar as well   TFlags      myFlags   myFlags    EFlagTwo  myFlags    EFlagThree   if  myFlags  amp  EFlagTwo       std  cout  lt  lt   flag 2 is set   lt  lt  std  endl  if   myFlags  amp  EFlagFour     EFlagsNone       std  cout  lt  lt   flag 4 is not set   lt  lt  std  endl    And you can also override the underlying type for binary-stable enums  like C  11 s enum foo   type  using the second template parameter  i e  typedef SafeEnum lt enum TFlags  uint8 t gt     TFlags    I marked the operator bool override with C  11 s explicit keyword to prevent it from resulting in int conversions  as those could cause sets of flags to end up collapsed into 0 or 1 when writing them out  If you can t use C  11  leave that overload out and rewrite the first conditional in the example usage as  myFlags  amp  EFlagTwo     EFlagTwo

User · Answer

In my opinion none of the answers so far are ideal   To be ideal I would expect the solution    Support the          amp   amp        and   operators in the conventional sense  i e  a  amp  b  Be type safe i e  not permit non-enumerated values such as literals or integer types to be assigned  except for bitwise combinations of enumerated values  or allow an enum variable to be assigned to an integer type Permit expressions such as if  a  amp  b     Not require evil macros  implementation specific features or other hacks   Most of the solutions thus far fall over on points 2 or 3   WebDancer s is the closes in my opinion but fails at point 3 and needs to be repeated for every enum   My proposed solution is a generalized version of WebDancer s that also addresses point 3    include  lt cstdint gt   include  lt type traits gt   template lt typename T   typename std  enable if lt std  is enum lt T gt   value  T gt   type gt  class auto bool       T val   public      constexpr auto bool T val    val  val         constexpr operator T   const   return val         constexpr explicit operator bool   const               return static cast lt std  underlying type t lt T gt  gt  val      0            template  lt typename T   typename std  enable if lt std  is enum lt T gt   value  T gt   type gt  constexpr auto bool lt T gt  operator amp  T lhs  T rhs        return static cast lt T gt           static cast lt typename std  underlying type lt T gt   type gt  lhs   amp          static cast lt typename std  underlying type lt T gt   type gt  rhs       template  lt typename T   typename std  enable if lt std  is enum lt T gt   value  T gt   type gt  constexpr T operator  T lhs  T rhs        return static cast lt T gt           static cast lt typename std  underlying type lt T gt   type gt  lhs            static cast lt typename std  underlying type lt T gt   type gt  rhs       enum class AnimalFlags   uint8 t        HasClaws   1      CanFly   2      EatsFish   4      Endangered   8     enum class PlantFlags   uint8 t       HasLeaves   1      HasFlowers   2      HasFruit   4      HasThorns   8     int main         AnimalFlags seahawk   AnimalFlags  CanFly            Compiles  as expected     AnimalFlags lion   AnimalFlags  HasClaws             Compiles  as expected     PlantFlags rose   PlantFlags  HasFlowers             Compiles  as expected     rose   1                                             Won t compile  as expected     if  seahawk    lion                                  Compiles  as expected     if  seahawk    rose                                  Won t compile  as expected     seahawk   PlantFlags  HasThorns                      Won t compile  as expected     seahawk   seahawk   AnimalFlags  EatsFish            Compiles  as expected     lion   AnimalFlags  HasClaws                         Compiles  as expected            AnimalFlags  Endangered      int eagle   AnimalFlags  CanFly                      Won t compile  as expected                 AnimalFlags  HasClaws      int has claws   seahawk  amp  AnimalFlags  CanFly        Won t compile  as expected     if  seahawk  amp  AnimalFlags  CanFly                    Compiles  as expected     seahawk   seahawk  amp  AnimalFlags  CanFly              Compiles  as expected      return 0      This creates overloads of the necessary operators but uses SFINAE to limit them to enumerated types   Note that in the interests of brevity I haven t defined all of the operators but the only one that is any different is the  amp    The operators are currently global  i e  apply to all enumerated types  but this could be reduced either by placing the overloads in a namespace  what I do   or by adding additional SFINAE conditions  perhaps using particular underlying types  or specially created type aliases    The underlying type t is a C  14 feature but it seems to be well supported and is easy to emulate for C  11 with a simple template lt typename T gt  using underlying type t   underlying type lt T gt   type

User · Answer

Note  also a bit off topic   Another way to make unique flags can be done using a bit shift  I  myself  find this easier to read   enum Flags       A   1  lt  lt  0     binary 0001     B   1  lt  lt  1     binary 0010     C   1  lt  lt  2     binary 0100     D   1  lt  lt  3     binary 1000      It can hold values up to an int so that is  most of the time  32 flags which is clearly reflected in the shift amount

User · Answer

Maybe like NS OPTIONS of Objective-C    define ENUM T1  T2    enum class T1   T2    inline T1 operator   T1 a    return  T1   int a      inline T1 operator   T1 a  T1 b    return static cast lt T1 gt   static cast lt T2 gt  a    static cast lt T2 gt  b         inline T1 operator amp   T1 a  T1 b    return static cast lt T1 gt   static cast lt T2 gt  a   amp  static cast lt T2 gt  b         inline T1 operator   T1 a  T1 b    return static cast lt T1 gt   static cast lt T2 gt  a    static cast lt T2 gt  b         inline T1 amp  operator    T1 amp  a  T1 b    return reinterpret cast lt T1 amp  gt   reinterpret cast lt T2 amp  gt  a     static cast lt T2 gt  b         inline T1 amp  operator amp    T1 amp  a  T1 b    return reinterpret cast lt T1 amp  gt   reinterpret cast lt T2 amp  gt  a   amp   static cast lt T2 gt  b         inline T1 amp  operator    T1 amp  a  T1 b    return reinterpret cast lt T1 amp  gt   reinterpret cast lt T2 amp  gt  a     static cast lt T2 gt  b         enum class T1   T2  ENUM Options  short        FIRST    1  lt  lt  0      SECOND   1  lt  lt  1      THIRD    1  lt  lt  2      FOURTH   1  lt  lt  3     auto options   Options  FIRST   Options  SECOND  options    Options  THIRD  if   options  amp  Options  SECOND     Options  SECOND      cout  lt  lt   Contains second option    lt  lt  endl  if   options  amp  Options  THIRD     Options  THIRD      cout  lt  lt   Contains third option    lt  lt  endl  return 0      Output     Contains second option      Contains third option

User · Answer

Note if you are working in Windows environment  there is a DEFINE ENUM FLAG OPERATORS macro defined in winnt h that does the job for you  So in this case  you can do this   enum AnimalFlags       HasClaws   1      CanFly  2      EatsFish   4      Endangered   8    DEFINE ENUM FLAG OPERATORS AnimalFlags   seahawk flags   CanFly   EatsFish   Endangered

[c++] How to use enums as flags in C++?

Examples related to c++

Examples related to enums