Allow for Range-Based For with enum classes?

Question

I have a recurrent chunk of code where I loop over all the members of an enum class.

The for loop that I currently use looks very unwieldly compared to the new range-based for.

Is there any way to take advantage of new C++11 features to cut down on the verbosity for my current for loop?

Current Code that I would like to improve:

enum class COLOR {     Blue,     Red,     Green,     Purple,     First=Blue,     Last=Purple };  inline COLOR operator++( COLOR& x ) { return x = (COLOR)(((int)(x) + 1)); }  int main(int argc, char** argv) {   // any way to improve the next line with range-based for?   for( COLOR c=COLOR::First; c!=COLOR::Last; ++c )   {     // do work   }   return 0; } 

In other words, it would be nice if I could do something like:

for( const auto& c : COLOR ) {   // do work } 

Answer 1

I personally don't like overloading the ++ operator for enums. Often incrementing an enum value doesn't really make sense. All that is really wanted is a way to iterator over the enum.

Below is an generic Enum class that supports iteration. It's functional but incomplete. A real implementation would do well to restrict access to the constructor and add all the iterator traits.

#include <iostream>  template< typename T > class Enum { public:    class Iterator    {    public:       Iterator( int value ) :          m_value( value )       { }        T operator*( void ) const       {          return (T)m_value;       }        void operator++( void )       {          ++m_value;       }        bool operator!=( Iterator rhs )       {          return m_value != rhs.m_value;       }     private:       int m_value;    };  };  template< typename T > typename Enum<T>::Iterator begin( Enum<T> ) {    return typename Enum<T>::Iterator( (int)T::First ); }  template< typename T > typename Enum<T>::Iterator end( Enum<T> ) {    return typename Enum<T>::Iterator( ((int)T::Last) + 1 ); }  enum class Color {    Red,    Green,    Blue,    First = Red,    Last = Blue };  int main() {    for( auto e: Enum<Color>() )    {       std::cout << ((int)e) << std::endl;    } } 

Answer 2

enum class Color {     blue,     red,     green = 5,     purple }; const std::array<Color,4> all_colors = {Color::blue, Color::red, Color::green, Color::purple}; 

Then:

for (Color c : all_colors) {     //... } 

Many times I use it like this, where I want a 'none' value:

// Color of a piece on a chess board enum class Color {     white,     black,     none }; const std::array<Color,3> colors = {Color::white, Color::black};  template <typename CONTAINER> bool has_item (CONTAINER const & c, typename CONTAINER::const_reference v) {     return std::find(c.begin(), c.end(), v) != c.end(); }  bool is_valid (Color c) {     return has_item(colors, c) || c == Color::none; }  bool do_it (Color c) {     assert(has_item(colors, c)); // here I want a real color, not none     // ... }  bool stop_it (Color c) {     assert(is_valid(c));         // but here I just want something valid     // ... }