[c++] Разрешить для Range-Based For с классами enum?


3 Answers

Мне лично не нравится перегружать оператор ++ для перечислений. Часто увеличение значения перечисления на самом деле не имеет смысла. Все, что действительно нужно, - это путь к итератору над перечислением.

Ниже приведен общий класс Enum , поддерживающий итерацию. Он функциональный, но неполный. Реальная реализация имела бы смысл ограничить доступ к конструктору и добавить все свойства итератора.

#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;
   }
}
Question

У меня есть повторяющийся фрагмент кода, где я перебираю все элементы enum class .

Цикл for который я использую в настоящее время, выглядит очень неудобно по сравнению с новым range-based for .

Есть ли способ использовать новые возможности C ++ 11 для сокращения многословия для моего текущего цикла?

Текущий код, который я хотел бы улучшить:

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;
}

Другими словами, было бы неплохо, если бы я мог сделать что-то вроде:

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



Если вы ужасный человек, вы можете получить это поведение с препроцессором, что-то вроде:

#include <vector>
#include <cstdio>

#define ENUM_NAME COLOR
#define ENUM_VALUES \
    ENUM_VALUE(Blue) \
    ENUM_VALUE(Red) \
    ENUM_VALUE(Green) \
    ENUM_VALUE(Purple)

// This block would be a #include "make_iterable_enum.h"
#define ENUM_VALUE(v) v,
enum class ENUM_NAME {ENUM_VALUES};
#undef ENUM_VALUE
#define ENUM_VALUE(v) ENUM_NAME::v,
#define VECTOR_NAME(v) values_ ## v
#define EXPAND_TO_VECTOR_NAME(v) VECTOR_NAME(v)
const std::vector<ENUM_NAME> EXPAND_TO_VECTOR_NAME(ENUM_NAME){ENUM_VALUES};
#undef ENUM_VALUE
#undef ENUM_NAME
#undef ENUM_VALUES
#undef VECTOR_NAME
#undef EXPAND_TO_VECTOR_NAME
// end #included block

int main() {
    for (auto v : COLOR_values) {
        printf("%d\n", (int)v);
    }
}

С небольшими изменениями это также может поддерживать, например. ENUM_SETVALUE (синий, 4) и создание карты констант, например. ЦВЕТ :: Синий - синий. И наоборот.

Я бы хотел, чтобы стандарт только что построил эти функции в качестве параметров для перечисления класса. Ни одно из обходных решений не является хорошим.




Вероятно, вы могли бы сделать что-то умное с boost :: mpl, грубая версия может выглядеть так:

#include <typeinfo>

// ---------------------------------------------------------------------------|
// Boost MPL
// ---------------------------------------------------------------------------|
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/mpl/range_c.hpp>

namespace mpl = boost::mpl;

using namespace std;

enum class COLOR 
{ 
   Blue,
   Red,
   Green,
   Purple,
   Last
};

struct enumValPrinter
{
    template< typename T >
    void operator() (const T&)
    {
        cout << "enumValPrinter with: " << typeid( T ).name() << " : " 
             << T::value << "\n";
    }
};

int main(int, char**)
{
    typedef mpl::range_c< int, static_cast<int>( COLOR::Blue ), 
                            static_cast<int>( COLOR::Last ) > Colors;
    mpl::for_each< Colors >( enumValPrinter() );
    return 0;
}



Мне очень нравится эта идея, и я часто ее желал.

Проблема, которую я вижу, - это то, что происходит, когда есть повторяющееся числовое значение для элемента перечисления. Все реализации, которые я вижу выше, требуют отбрасывания к интегральному типу и ++. В конечном счете, я думаю, что языковая поддержка может потребоваться для поистине перебора каждого элемента во всех случаях. Это устранит необходимость иметь First, Last или Begin, End, хотя я не возражаю против этого слишком много. Это похоже на поиск begin () end () для контейнеров.

enum class COLOR 
{
   Blue,
   Red,
   Green,
   Mauve = 0,
   Purple,
   Last
};

Нумерация начинается с Mauve.




Related