Как я могу перебрать перечисление?

Question

Я только что заметил, что вы не можете использовать стандартные математические операторы для перечисления, такие как ++ или + =

Так, каков наилучший способ перебрать все значения в перечислении C ++?

Answer 1

Типичный способ выглядит следующим образом:

enum Foo {
  One,
  Two,
  Three,
  Last
};

for ( int fooInt = One; fooInt != Last; fooInt++ )
{
   Foo foo = static_cast<Foo>(fooInt);
   // ...
}

Конечно, это не работает, если указаны значения перечисления:

enum Foo {
  One = 1,
  Two = 9,
  Three = 4,
  Last
};

Это показывает, что перечисление на самом деле не предназначено для итерации. Типичный способ работы с enum - это использовать его в операторе switch.

switch ( foo )
{
    case One:
        // ..
        break;
    case Two:  // intentional fall-through
    case Three:
        // ..
        break;
    case Four:
        // ..
        break;
     default:
        assert( ! "Invalid Foo enum value" );
        break;
}

Если вы действительно хотите перечислить, поместите значения перечисления в вектор и выполните итерации по нему Это будет правильно работать с указанными значениями перечисления.

Answer 2

#include <iostream>
#include <algorithm>

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

Answer 3

Если ваше перечисление начинается с 0, а приращение всегда равно 1.

enum enumType 
{ 
    A = 0,
    B,
    C,
    enumTypeEnd
};

for(int i=0; i<enumTypeEnd; i++)
{
   enumType eCurrent = (enumType) i;            
}

Если нет, я думаю, единственное, почему нужно создать нечто вроде

vector<enumType> vEnums;

добавить элементы и использовать обычные итераторы ....

Answer 4

С c ++ 11 на самом деле есть альтернатива: написание простого шаблонного пользовательского итератора.

давайте предположим, что ваше перечисление

enum class foo {
  one,
  two,
  three
};

Этот универсальный код достаточно эффективен - поместите его в универсальный заголовок, он будет служить вам для любого перечисления, которое вам может понадобиться для перебора:

#include <type_traits>
template < typename C, C beginVal, C endVal>
class Iterator {
  typedef typename std::underlying_type<C>::type val_t;
  int val;
public:
  Iterator(const C & f) : val(static_cast<val_t>(f)) {}
  Iterator() : val(static_cast<val_t>(beginVal)) {}
  Iterator operator++() {
    ++val;
    return *this;
  }
  C operator*() { return static_cast<C>(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& i) { return val != i.val; }
};

Вам нужно будет специализироваться

typedef Iterator<foo, foo::one, foo::three> fooIterator;

И затем вы можете выполнить итерацию, используя range-for

for (foo i : fooIterator() ) { //notice the parentheses!
   do_stuff(i);
}

Предположение, что в вашем перечислении нет пробелов, все еще верно; нет никакого предположения о количестве битов, фактически необходимых для хранения значения перечисления (благодаря std :: basic_type)

Answer 5

слишком сложное решение, я делаю так:

enum NodePosition { Primary = 0, Secondary = 1, Tertiary = 2, Quaternary = 3};

const NodePosition NodePositionVector[] = { Primary, Secondary, Tertiary, Quaternary };

for (NodePosition pos : NodePositionVector) {
...
}

Answer 6

Вы не можете с перечислением. Возможно, перечисление не совсем подходит для вашей ситуации.

Общепринятым условием является присвоение имени последнему перечислению что-то вроде MAX и использование его для управления циклом с использованием int.

Answer 7

Я часто так делаю

    enum EMyEnum
    {
        E_First,
        E_Orange = E_First,
        E_Green,
        E_White,
        E_Blue,
        E_Last
    }

    for (EMyEnum i = E_First; i < E_Last; i = EMyEnum(i + 1))
    {}

или если не последовательно, но с регулярным шагом (например, битовые флаги)

    enum EAnimal
    {
        E_First,
        E_None    = E_First,
        E_CanFly  = 0x1,
        E_CanWalk = 0x2
        E_CanSwim = 0x4,
        E_Last
    }

    for (EAnimali = E_First; i < E_Last; i = EAnimal(i << 1))
    {}

Answer 8

Вы можете попытаться определить следующий макрос:

#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))

Теперь вы можете использовать его:

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

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

Может использоваться для перемотки вперед и назад через беззнаковые, целые, перечисления и символы:

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


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

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

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

Вы явно не можете перебирать перечисляемые типы с пробелами.

Answer 9

То, что не было рассмотрено в других ответах = если вы используете строго типизированные перечисления C ++ 11, вы не можете использовать ++ или + int для них. В этом случае требуется более сложное решение:

enum class myenumtype {
  MYENUM_FIRST,
  MYENUM_OTHER,
  MYENUM_LAST
}

for(myenumtype myenum = myenumtype::MYENUM_FIRST;
    myenum != myenumtype::MYENUM_LAST;
    myenum = static_cast<myenumtype>(static_cast<int>(myenum) + 1)) {

  do_whatever(myenum)

}

Answer 10

Вы также можете перегрузить операторы увеличения / уменьшения для вашего перечисляемого типа.