How can I iterate over an enum

Question

I just noticed that you can not use standard math operators on an enum such as    or     So what is the best way to iterate through all of the values in a C   enum

User · Answer

You can try and define the following macro:

#define for_range(_type, _param, _A1, _B1) for (bool _ok = true; _ok;)\
for (_type _start = _A1, _finish = _B1; _ok;)\
    for (int _step = 2*(((int)_finish)>(int)_start)-1;_ok;)\
         for (_type _param = _start; _ok ; \
 (_param != _finish ? \
           _param = static_cast<_type>(((int)_param)+_step) : _ok = false))

Now you can use it:

enum Count { zero, one, two, three }; 

    for_range (Count, c, zero, three)
    {
        cout << "forward: " << c << endl;
    }

It can be used to iterate backwards and forwards through unsigned, integers, enums and chars:

for_range (unsigned, i, 10,0)
{
    cout << "backwards i: " << i << endl;
}


for_range (char, c, 'z','a')
{
    cout << c << endl;
}

Despite its awkward definition it is optimized very well. I looked at disassembler in VC++. The code is extremely efficient. Don't be put off but the three for statements: the compiler will produce only one loop after optimization! You can even define enclosed loops:

unsigned p[4][5];

for_range (Count, i, zero,three)
    for_range(unsigned int, j, 4, 0)
    {   
        p[i][j] = static_cast<unsigned>(i)+j;
    }

You obviously cannot iterate through enumerated types with gaps.

User · Answer

You can t with an enum   Maybe an enum isn t the best fit for your situation   A common convention is to name the last enum value something like MAX and use that to control a loop using an int

User · Answer

too much complicated these solution  i do like that    enum NodePosition   Primary   0  Secondary   1  Tertiary   2  Quaternary   3    const NodePosition NodePositionVector       Primary  Secondary  Tertiary  Quaternary     for  NodePosition pos   NodePositionVector

User · Answer

typedef enum      first   2      second   6      third   17  MyEnum   static const int enumItems           first      second      third    static const int EnumLength   sizeof enumItems    sizeof int    for int i   0  i  lt  EnumLength  i           Do something with enumItems i

User · Answer

If your enum starts with 0 and the increment is always 1   enum enumType         A   0      B      C      enumTypeEnd     for int i 0  i lt enumTypeEnd  i         enumType eCurrent    enumType  i                  If not I guess the only why is to create something like a  vector lt enumType gt  vEnums    add the items  and use normal iterators

User · Answer

You can also overload the increment decrement operators for your enumerated type

User · Answer

If your enum starts with 0 and the increment is always 1   enum enumType         A   0      B      C      enumTypeEnd     for int i 0  i lt enumTypeEnd  i         enumType eCurrent    enumType  i                  If not I guess the only why is to create something like a  vector lt enumType gt  vEnums    add the items  and use normal iterators

User · Answer

The typical way is as follows   enum Foo     One    Two    Three    Last     for   int fooInt   One  fooInt    Last  fooInt          Foo foo   static cast lt Foo gt  fooInt                 Please note  the enum Last is meant to be skipped by the iteration  Utilizing this  fake  Last enum  you don t have to update your terminating condition in the for loop to the last  real  enum each time you want to add a new enum  If you want to add more enums later  just add them before Last  The loop in this example will still work    Of course  this breaks down if the enum values are specified   enum Foo     One   1    Two   9    Three   4    Last      This illustrates that an enum is not really meant to iterate through  The typical way to deal with an enum is to use it in a switch statement   switch   foo         case One                        break      case Two      intentional fall-through     case Three                        break      case Four                        break       default          assert     Invalid Foo enum value             break      If you really want to enumerate  stuff the enum values in a vector and iterate over that  This will properly deal with the specified enum values as well

User · Answer

C   doesn t have introspection  so you can t determine this kind of thing at run-time

User · Answer

You can also overload the increment decrement operators for your enumerated type

User · Answer

You can t with an enum   Maybe an enum isn t the best fit for your situation   A common convention is to name the last enum value something like MAX and use that to control a loop using an int

User · Answer

With c  11  there actually is an alternative  writing a simple templatized custom iterator   let s assume your enum is  enum class foo     one    two    three      This generic code will do the trick  quite efficiently - place in a generic header  it ll serve you for any enum you may need to iterate over    include  lt type traits gt  template  lt  typename C  C beginVal  C endVal gt  class Iterator     typedef typename std  underlying type lt C gt   type val t    int val  public    Iterator const C  amp  f    val static cast lt val t gt  f        Iterator     val static cast lt val t gt  beginVal        Iterator operator             val      return  this        C operator      return static cast lt C gt  val       Iterator begin     return  this      default ctor is good   Iterator end           static const Iterator endIter   Iterator endVal      cache it       return endIter        bool operator   const Iterator amp  i    return val    i val         You ll need to specialize it  typedef Iterator lt foo  foo  one  foo  three gt  fooIterator    And then you can iterate using range-for  for  foo i   fooIterator         notice the parentheses     do stuff i       The assumption that you don t have gaps in your enum is still true  there is no assumption on the number of bits actually needed to store the enum value  thanks to std  underlying type

User · Answer

With c  11  there actually is an alternative  writing a simple templatized custom iterator   let s assume your enum is  enum class foo     one    two    three      This generic code will do the trick  quite efficiently - place in a generic header  it ll serve you for any enum you may need to iterate over    include  lt type traits gt  template  lt  typename C  C beginVal  C endVal gt  class Iterator     typedef typename std  underlying type lt C gt   type val t    int val  public    Iterator const C  amp  f    val static cast lt val t gt  f        Iterator     val static cast lt val t gt  beginVal        Iterator operator             val      return  this        C operator      return static cast lt C gt  val       Iterator begin     return  this      default ctor is good   Iterator end           static const Iterator endIter   Iterator endVal      cache it       return endIter        bool operator   const Iterator amp  i    return val    i val         You ll need to specialize it  typedef Iterator lt foo  foo  one  foo  three gt  fooIterator    And then you can iterate using range-for  for  foo i   fooIterator         notice the parentheses     do stuff i       The assumption that you don t have gaps in your enum is still true  there is no assumption on the number of bits actually needed to store the enum value  thanks to std  underlying type

User · Answer

For MS compilers    define inc enum i    decltype i     int i   1    enum enumtype   one  two  three  count   for enumtype i   one  i  lt  count  i   inc enum i          dostuff i        Note  this is a lot less code than the simple templatized custom iterator answer   You can get this to work with GCC by using typeof instead of decltype  but I don t have that compiler handy at the moment to make sure it compiles

User · Answer

Assuming that enum is numbered sequentially is error prone  Moreover  you may want to iterate over selected enumerators only  If that subset is small  looping over it explicitly might be an elegant choice   enum Item   Man  Wolf  Goat  Cabbage       or enum class  for  auto item    Wolf  Goat  Cabbage        or Item  Wolf

User · Answer

C   doesn t have introspection  so you can t determine this kind of thing at run-time

User · Answer

The typical way is as follows   enum Foo     One    Two    Three    Last     for   int fooInt   One  fooInt    Last  fooInt          Foo foo   static cast lt Foo gt  fooInt                 Please note  the enum Last is meant to be skipped by the iteration  Utilizing this  fake  Last enum  you don t have to update your terminating condition in the for loop to the last  real  enum each time you want to add a new enum  If you want to add more enums later  just add them before Last  The loop in this example will still work    Of course  this breaks down if the enum values are specified   enum Foo     One   1    Two   9    Three   4    Last      This illustrates that an enum is not really meant to iterate through  The typical way to deal with an enum is to use it in a switch statement   switch   foo         case One                        break      case Two      intentional fall-through     case Three                        break      case Four                        break       default          assert     Invalid Foo enum value             break      If you really want to enumerate  stuff the enum values in a vector and iterate over that  This will properly deal with the specified enum values as well

User · Answer

I often do it like that      enum EMyEnum               E First          E Orange   E First          E Green          E White          E Blue          E Last            for  EMyEnum i   E First  i  lt  E Last  i   EMyEnum i   1            or if not successive  but with regular step  e g  bit flags       enum EAnimalCaps               E First          E None      E First          E CanFly    0x1          E CanWalk   0x2         E CanSwim   0x4          E Last            class MyAnimal              EAnimalCaps m Caps             class Frog               Frog                  m Caps EAnimalCaps E CanWalk   E CanSwim                         for  EAnimalCaps  E First  i  lt  E Last  i   EAnimalCaps i  lt  lt  1

User · Answer

Here s another solution which only works for contiguous enums   It gives the expected iteration  except for ugliness in the increment  which is where it belongs  since that s what s broken in C     enum Bar       One   1      Two      Three      End Bar    Marker for end of enum       for  Bar foo   One  foo  lt  End Bar  foo   Bar foo   1

User · Answer

Something that hasn t been covered in the other answers   if you re using strongly typed C  11 enums  you cannot use    or   int on them   In that case  a bit of a messier solution is required   enum class myenumtype     MYENUM FIRST    MYENUM OTHER    MYENUM LAST    for myenumtype myenum   myenumtype  MYENUM FIRST      myenum    myenumtype  MYENUM LAST      myenum   static cast lt myenumtype gt  static cast lt int gt  myenum    1        do whatever myenum

User · Answer

Assuming that enum is numbered sequentially is error prone  Moreover  you may want to iterate over selected enumerators only  If that subset is small  looping over it explicitly might be an elegant choice   enum Item   Man  Wolf  Goat  Cabbage       or enum class  for  auto item    Wolf  Goat  Cabbage        or Item  Wolf

User · Answer

Something that hasn t been covered in the other answers   if you re using strongly typed C  11 enums  you cannot use    or   int on them   In that case  a bit of a messier solution is required   enum class myenumtype     MYENUM FIRST    MYENUM OTHER    MYENUM LAST    for myenumtype myenum   myenumtype  MYENUM FIRST      myenum    myenumtype  MYENUM LAST      myenum   static cast lt myenumtype gt  static cast lt int gt  myenum    1        do whatever myenum

User · Answer

You can also overload the increment decrement operators for your enumerated type

User · Answer

In Bjarne Stroustrup s C   programming language book  you can read that he s proposing to overload the operator   for your specific enum  enum are user-defined types and overloading operator exists in the language for these specific situations    You ll be able to code the following      include  lt iostream gt  enum class Colors red  green  blue   Colors amp  operator   Colors  amp c  int         switch c                    case Colors  red                 return c Colors  green             case Colors  green                 return c Colors  blue             case Colors  blue                 return c Colors  red     managing overflow            default                 throw std  exception       or do anything else to manage the error              int main         Colors c   Colors  red         casting in int just for convenience of output       std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      return 0      test code  http   cpp sh 357gb  Mind that I m using enum class  Code works fine with enum also  But I prefer enum class since they are strong typed and can prevent us to make mistake at compile time

User · Answer

enum class A       a0 0  a3 3  a4 4    constexpr std  array lt A  3 gt  ALL A  A  a0  A  a3  A  a4      constexpr is important here  for A a  ALL A      if a  A  a0    a  A  a4  std  cout  lt  lt  static cast lt int gt  a       A constexpr std  array can iterate even non-sequential enums without the array being instantiated by the compiler  This depends on things like the compiler s optimization heuristics and whether you take the array s address    In my experiments  I found that g   9 1 with -O3 will optimize away the above array if there are 2 non-sequential values or quite a few sequential values  I tested up to 6   But it only does this if you have an if statement   I tried a statement that compared an integer value greater than all the elements in a sequential array and it inlined the iteration despite none being excluded  but when I left out the if statement  the values were put in memory   It also inlined 5 values from a non-sequential enum in  one case https   godbolt org z XuGtoc   I suspect this odd behavior is due to deep heuristics having to do with caches and branch prediction   Here is a link to a simple test iteration on godbolt that demonstrates the array does not always get instantiated   The price of this technique is writing the enum elements twice and keeping the two lists in sync

User · Answer

too much complicated these solution  i do like that    enum NodePosition   Primary   0  Secondary   1  Tertiary   2  Quaternary   3    const NodePosition NodePositionVector       Primary  Secondary  Tertiary  Quaternary     for  NodePosition pos   NodePositionVector

User · Answer

Just make an array of ints and loop over the array  but make the last element say -1 and use it for exit condition   If enum is   enum MyEnumType Hay 12 Grass 42 Beer 39     then create array   int Array      Hay Grass Beer -1    for  int h   0  Array h     -1  h       doStuff   MyEnumType  Array h         This does not break down no matter the ints in the representation as long as -1 check does not collide with one of the elements of course

User · Answer

Most solution are based on loops over the  MIN  MAX  range but overlook the fact that might be holes in the enum  My suggestions is          for  int i   MYTYPE MIN  i  lt   MYTYPE MAX  i                  if  MYTYPE IsValid i                     MYTYPE value    MYTYPE i                     DoStuff value

User · Answer

If you do not like to pollute you enum with a final COUNT item  because maybe if you also use the enum in a switch then then the compiler will warn you of a missing case COUNT    you can do this   enum Colour  Red  Green  Blue   const Colour LastColour   Blue   Colour co 0   while  true         do stuff with co            if  co    LastColour  break    co   Colour co 1

User · Answer

include  lt iostream gt   include  lt algorithm gt   namespace MyEnum     enum Type         a   100      b   220      c   -1         static const Type All       a  b  c       void fun  const MyEnum  Type e       std  cout  lt  lt  e  lt  lt  std  endl     int main          all   for   const auto e   MyEnum  All       fun  e          some   for   const auto e     MyEnum  a  MyEnum  b         fun  e          all   std  for each  std  begin  MyEnum  All    std  end  MyEnum  All    fun       return 0

User · Answer

enum class A       a0 0  a3 3  a4 4    constexpr std  array lt A  3 gt  ALL A  A  a0  A  a3  A  a4      constexpr is important here  for A a  ALL A      if a  A  a0    a  A  a4  std  cout  lt  lt  static cast lt int gt  a       A constexpr std  array can iterate even non-sequential enums without the array being instantiated by the compiler  This depends on things like the compiler s optimization heuristics and whether you take the array s address    In my experiments  I found that g   9 1 with -O3 will optimize away the above array if there are 2 non-sequential values or quite a few sequential values  I tested up to 6   But it only does this if you have an if statement   I tried a statement that compared an integer value greater than all the elements in a sequential array and it inlined the iteration despite none being excluded  but when I left out the if statement  the values were put in memory   It also inlined 5 values from a non-sequential enum in  one case https   godbolt org z XuGtoc   I suspect this odd behavior is due to deep heuristics having to do with caches and branch prediction   Here is a link to a simple test iteration on godbolt that demonstrates the array does not always get instantiated   The price of this technique is writing the enum elements twice and keeping the two lists in sync

User · Answer

In Bjarne Stroustrup s C   programming language book  you can read that he s proposing to overload the operator   for your specific enum  enum are user-defined types and overloading operator exists in the language for these specific situations    You ll be able to code the following      include  lt iostream gt  enum class Colors red  green  blue   Colors amp  operator   Colors  amp c  int         switch c                    case Colors  red                 return c Colors  green             case Colors  green                 return c Colors  blue             case Colors  blue                 return c Colors  red     managing overflow            default                 throw std  exception       or do anything else to manage the error              int main         Colors c   Colors  red         casting in int just for convenience of output       std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      std  cout  lt  lt   int c    lt  lt  std  endl      return 0      test code  http   cpp sh 357gb  Mind that I m using enum class  Code works fine with enum also  But I prefer enum class since they are strong typed and can prevent us to make mistake at compile time

User · Answer

typedef enum      first   2      second   6      third   17  MyEnum   static const int enumItems           first      second      third    static const int EnumLength   sizeof enumItems    sizeof int    for int i   0  i  lt  EnumLength  i           Do something with enumItems i

User · Answer

C   doesn t have introspection  so you can t determine this kind of thing at run-time

User · Answer

You can t with an enum   Maybe an enum isn t the best fit for your situation   A common convention is to name the last enum value something like MAX and use that to control a loop using an int

User · Answer

I often do it like that      enum EMyEnum               E First          E Orange   E First          E Green          E White          E Blue          E Last            for  EMyEnum i   E First  i  lt  E Last  i   EMyEnum i   1            or if not successive  but with regular step  e g  bit flags       enum EAnimalCaps               E First          E None      E First          E CanFly    0x1          E CanWalk   0x2         E CanSwim   0x4          E Last            class MyAnimal              EAnimalCaps m Caps             class Frog               Frog                  m Caps EAnimalCaps E CanWalk   E CanSwim                         for  EAnimalCaps  E First  i  lt  E Last  i   EAnimalCaps i  lt  lt  1

User · Answer

Most solution are based on loops over the  MIN  MAX  range but overlook the fact that might be holes in the enum  My suggestions is          for  int i   MYTYPE MIN  i  lt   MYTYPE MAX  i                  if  MYTYPE IsValid i                     MYTYPE value    MYTYPE i                     DoStuff value

User · Answer

C   doesn t have introspection  so you can t determine this kind of thing at run-time

User · Answer

The typical way is as follows   enum Foo     One    Two    Three    Last     for   int fooInt   One  fooInt    Last  fooInt          Foo foo   static cast lt Foo gt  fooInt                 Please note  the enum Last is meant to be skipped by the iteration  Utilizing this  fake  Last enum  you don t have to update your terminating condition in the for loop to the last  real  enum each time you want to add a new enum  If you want to add more enums later  just add them before Last  The loop in this example will still work    Of course  this breaks down if the enum values are specified   enum Foo     One   1    Two   9    Three   4    Last      This illustrates that an enum is not really meant to iterate through  The typical way to deal with an enum is to use it in a switch statement   switch   foo         case One                        break      case Two      intentional fall-through     case Three                        break      case Four                        break       default          assert     Invalid Foo enum value             break      If you really want to enumerate  stuff the enum values in a vector and iterate over that  This will properly deal with the specified enum values as well

User · Answer

If you knew that the enum values were sequential  for example the Qt Key enum  you could   Qt  Key shortcut key   Qt  Key 0  for  int idx   0  etc                    if  shortcut key  lt   Qt  Key 9            fileMenu- gt addAction  abc   this  SLOT onNewTab                                 QKeySequence Qt  CTRL   shortcut key            shortcut key    Qt  Key   shortcut key   1             It works as expected

User · Answer

If your enum starts with 0 and the increment is always 1   enum enumType         A   0      B      C      enumTypeEnd     for int i 0  i lt enumTypeEnd  i         enumType eCurrent    enumType  i                  If not I guess the only why is to create something like a  vector lt enumType gt  vEnums    add the items  and use normal iterators

User · Answer

Upsides  enums can have any values you like in any order you like and it s still easy to iterate over them  Names and values are defined once  in the first  define  Downsides  if you use this at work  you need a whole paragraph to explain it to your coworkers  And  it s annoying to have to declare memory to give your loop something to iterate over  but I don t know of a workaround that doesn t confine you to enums with adjacent values  and if the enum will always have adjacent values  the enum might not be buying you all that much anyway     create a  b  c  d as 0  5  6  7  define LIST x a  x b  5  x c  x d   define x n       n   VA ARGS    enum MyEnum  LIST     define the enum  undef x   needed  define x n      n   MyEnum myWalkableEnum    LIST     define an iterable list of enum values  undef x   neatness  int main       std  cout  lt  lt  d    for  auto z   myWalkableEnum      std  cout  lt  lt  z      outputs 70567  The trick of declaring a list with an undefined macro wrapper  and then defining the wrapper differently in various situations  has a lot of applications other than this one

User · Answer

Extending  Eponymous s answer  It s great  but doesn t provide a general syntax  Here s what I came up with     Common EnumTools h  pragma once   include  lt array gt   namespace Common       Here we forward-declare metafunction for mapping enums to their values     Since C   lt 23 doesn t have reflection  you have to populate it yourself  -     Usage  After declaring enum class E  add this overload in the namespace of E     inline constexpr auto allValuesArray const E amp   Commob  EnumAllValuesTag    return std  array E  foo  E  bar        Then  AllValues lt NS  E gt   will call  allValuesArray NS  E    EnumAllValuesTag   which will resolve    by ADL     Just be sure to keep it sync d with your enum      Here s what you want to use in  e g   loops   quot for  auto val   Common  AllValues lt MyEnum gt     quot   struct EnumAllValuesTag        So your allValuesArray function is clearly associated with this header   template  lt typename Enum gt  static inline constexpr auto AllValues   allValuesArray Enum    EnumAllValuesTag          Just  quot constexpr auto quot  or  quot constexpr std  array lt Enum  allValuesArray Enum    EnumAllValuesTag    size   gt  quot  didn t work on all compilers I m using  but this did        namespace Common  then in your namespace   include  quot Common EnumTools h quot   namespace MyNamespace    enum class MyEnum       foo      bar   4      baz   42         Making this not have to be in the  Common  namespace took some thinking     but is a critical feature since otherwise there s no hope in keeping it sync d with the enum  inline constexpr auto allValuesArray const MyEnum amp   Common  EnumAllValuesTag        return std  array  MyEnum  foo  MyEnum  bar  MyEnum  baz            namespace MyNamespace  then wherever you need to use it  for  const auto amp  e   Common  AllValues lt MyNamespace  MyEnum gt            so even if you ve typedef d  namespace YourNS   using E   MyNamespace  MyEnum       namespace YourNS  for  const auto amp  e   Common  AllValues lt YourNS  E gt            I can t think of anything much better  short of the actual language feature everyone looking at this page want  Future work   You should be able to add a constexpr function  and so a metafunction  that filters Common  AllValues lt E gt  to provide a Common  AllDistinctValues lt E gt  for the case of enums with repeated numerical values like enum   foo   0  bar   0     I bet there s a way to use the compiler s switch-covers-all-enum-values to write allValuesArray such that it errors if the enum has added a value

User · Answer

For MS compilers    define inc enum i    decltype i     int i   1    enum enumtype   one  two  three  count   for enumtype i   one  i  lt  count  i   inc enum i          dostuff i        Note  this is a lot less code than the simple templatized custom iterator answer   You can get this to work with GCC by using typeof instead of decltype  but I don t have that compiler handy at the moment to make sure it compiles

User · Answer

Just make an array of ints and loop over the array  but make the last element say -1 and use it for exit condition   If enum is   enum MyEnumType Hay 12 Grass 42 Beer 39     then create array   int Array      Hay Grass Beer -1    for  int h   0  Array h     -1  h       doStuff   MyEnumType  Array h         This does not break down no matter the ints in the representation as long as -1 check does not collide with one of the elements of course

User · Answer

Extending  Eponymous s answer  It s great  but doesn t provide a general syntax  Here s what I came up with     Common EnumTools h  pragma once   include  lt array gt   namespace Common       Here we forward-declare metafunction for mapping enums to their values     Since C   lt 23 doesn t have reflection  you have to populate it yourself  -     Usage  After declaring enum class E  add this overload in the namespace of E     inline constexpr auto allValuesArray const E amp   Commob  EnumAllValuesTag    return std  array E  foo  E  bar        Then  AllValues lt NS  E gt   will call  allValuesArray NS  E    EnumAllValuesTag   which will resolve    by ADL     Just be sure to keep it sync d with your enum      Here s what you want to use in  e g   loops   quot for  auto val   Common  AllValues lt MyEnum gt     quot   struct EnumAllValuesTag        So your allValuesArray function is clearly associated with this header   template  lt typename Enum gt  static inline constexpr auto AllValues   allValuesArray Enum    EnumAllValuesTag          Just  quot constexpr auto quot  or  quot constexpr std  array lt Enum  allValuesArray Enum    EnumAllValuesTag    size   gt  quot  didn t work on all compilers I m using  but this did        namespace Common  then in your namespace   include  quot Common EnumTools h quot   namespace MyNamespace    enum class MyEnum       foo      bar   4      baz   42         Making this not have to be in the  Common  namespace took some thinking     but is a critical feature since otherwise there s no hope in keeping it sync d with the enum  inline constexpr auto allValuesArray const MyEnum amp   Common  EnumAllValuesTag        return std  array  MyEnum  foo  MyEnum  bar  MyEnum  baz            namespace MyNamespace  then wherever you need to use it  for  const auto amp  e   Common  AllValues lt MyNamespace  MyEnum gt            so even if you ve typedef d  namespace YourNS   using E   MyNamespace  MyEnum       namespace YourNS  for  const auto amp  e   Common  AllValues lt YourNS  E gt            I can t think of anything much better  short of the actual language feature everyone looking at this page want  Future work   You should be able to add a constexpr function  and so a metafunction  that filters Common  AllValues lt E gt  to provide a Common  AllDistinctValues lt E gt  for the case of enums with repeated numerical values like enum   foo   0  bar   0     I bet there s a way to use the compiler s switch-covers-all-enum-values to write allValuesArray such that it errors if the enum has added a value

User · Answer

Upsides  enums can have any values you like in any order you like and it s still easy to iterate over them  Names and values are defined once  in the first  define  Downsides  if you use this at work  you need a whole paragraph to explain it to your coworkers  And  it s annoying to have to declare memory to give your loop something to iterate over  but I don t know of a workaround that doesn t confine you to enums with adjacent values  and if the enum will always have adjacent values  the enum might not be buying you all that much anyway     create a  b  c  d as 0  5  6  7  define LIST x a  x b  5  x c  x d   define x n       n   VA ARGS    enum MyEnum  LIST     define the enum  undef x   needed  define x n      n   MyEnum myWalkableEnum    LIST     define an iterable list of enum values  undef x   neatness  int main       std  cout  lt  lt  d    for  auto z   myWalkableEnum      std  cout  lt  lt  z      outputs 70567  The trick of declaring a list with an undefined macro wrapper  and then defining the wrapper differently in various situations  has a lot of applications other than this one

User · Answer

You can t with an enum   Maybe an enum isn t the best fit for your situation   A common convention is to name the last enum value something like MAX and use that to control a loop using an int

User · Answer

If your enum starts with 0 and the increment is always 1   enum enumType         A   0      B      C      enumTypeEnd     for int i 0  i lt enumTypeEnd  i         enumType eCurrent    enumType  i                  If not I guess the only why is to create something like a  vector lt enumType gt  vEnums    add the items  and use normal iterators

User · Answer

You can also overload the increment decrement operators for your enumerated type

User · Answer

The typical way is as follows   enum Foo     One    Two    Three    Last     for   int fooInt   One  fooInt    Last  fooInt          Foo foo   static cast lt Foo gt  fooInt                 Please note  the enum Last is meant to be skipped by the iteration  Utilizing this  fake  Last enum  you don t have to update your terminating condition in the for loop to the last  real  enum each time you want to add a new enum  If you want to add more enums later  just add them before Last  The loop in this example will still work    Of course  this breaks down if the enum values are specified   enum Foo     One   1    Two   9    Three   4    Last      This illustrates that an enum is not really meant to iterate through  The typical way to deal with an enum is to use it in a switch statement   switch   foo         case One                        break      case Two      intentional fall-through     case Three                        break      case Four                        break       default          assert     Invalid Foo enum value             break      If you really want to enumerate  stuff the enum values in a vector and iterate over that  This will properly deal with the specified enum values as well

User · Answer

Here s another solution which only works for contiguous enums   It gives the expected iteration  except for ugliness in the increment  which is where it belongs  since that s what s broken in C     enum Bar       One   1      Two      Three      End Bar    Marker for end of enum       for  Bar foo   One  foo  lt  End Bar  foo   Bar foo   1

User · Answer

If you do not like to pollute you enum with a final COUNT item  because maybe if you also use the enum in a switch then then the compiler will warn you of a missing case COUNT    you can do this   enum Colour  Red  Green  Blue   const Colour LastColour   Blue   Colour co 0   while  true         do stuff with co            if  co    LastColour  break    co   Colour co 1

User · Answer

If you knew that the enum values were sequential  for example the Qt Key enum  you could   Qt  Key shortcut key   Qt  Key 0  for  int idx   0  etc                    if  shortcut key  lt   Qt  Key 9            fileMenu- gt addAction  abc   this  SLOT onNewTab                                 QKeySequence Qt  CTRL   shortcut key            shortcut key    Qt  Key   shortcut key   1             It works as expected

User · Answer

You can try and define the following macro:

#define for_range(_type, _param, _A1, _B1) for (bool _ok = true; _ok;)\
for (_type _start = _A1, _finish = _B1; _ok;)\
    for (int _step = 2*(((int)_finish)>(int)_start)-1;_ok;)\
         for (_type _param = _start; _ok ; \
 (_param != _finish ? \
           _param = static_cast<_type>(((int)_param)+_step) : _ok = false))

Now you can use it:

enum Count { zero, one, two, three }; 

    for_range (Count, c, zero, three)
    {
        cout << "forward: " << c << endl;
    }

It can be used to iterate backwards and forwards through unsigned, integers, enums and chars:

for_range (unsigned, i, 10,0)
{
    cout << "backwards i: " << i << endl;
}


for_range (char, c, 'z','a')
{
    cout << c << endl;
}

Despite its awkward definition it is optimized very well. I looked at disassembler in VC++. The code is extremely efficient. Don't be put off but the three for statements: the compiler will produce only one loop after optimization! You can even define enclosed loops:

unsigned p[4][5];

for_range (Count, i, zero,three)
    for_range(unsigned int, j, 4, 0)
    {   
        p[i][j] = static_cast<unsigned>(i)+j;
    }

You obviously cannot iterate through enumerated types with gaps.

User · Answer

include  lt iostream gt   include  lt algorithm gt   namespace MyEnum     enum Type         a   100      b   220      c   -1         static const Type All       a  b  c       void fun  const MyEnum  Type e       std  cout  lt  lt  e  lt  lt  std  endl     int main          all   for   const auto e   MyEnum  All       fun  e          some   for   const auto e     MyEnum  a  MyEnum  b         fun  e          all   std  for each  std  begin  MyEnum  All    std  end  MyEnum  All    fun       return 0

[c++] How can I iterate over an enum?

Examples related to c++

Examples related to enums