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

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

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

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

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

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

Обратите внимание, что перечисление Last должно пропускаться итерацией. Используя это «поддельное» перечисление Last, вам не нужно обновлять условие завершения в цикле for до последнего «реального» перечисления каждый раз, когда вы хотите добавить новое перечисление. Если вы хотите добавить больше перечислений позже, просто добавьте их перед Last. Цикл в этом примере по-прежнему будет работать.

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

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

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

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

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

В C++ нет интроспекции, поэтому вы не можете определить такие вещи во время выполнения.

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

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

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

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

vector<enumType> vEnums;

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

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

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

#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++. Код чрезвычайно эффективен. Не откладывайте, но три оператора for: компилятор произведет только один цикл после оптимизации! Вы даже можете определять замкнутые циклы:

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

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

То, что не было рассмотрено в других ответах = если вы используете строго типизированные перечисления 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)

}

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

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

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

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

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

В 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 :: lower_type)

Для компиляторов MS:

#define inc_enum(i) ((decltype(i)) ((int)i + 1))

enum enumtype { one, two, three, count};
for(enumtype i = one; i < count; i = inc_enum(i))
{ 
    dostuff(i); 
}

Примечание: это намного меньше кода, чем простой шаблонный ответ настраиваемого итератора.

Вы можете заставить это работать с GCC, используя typeof вместо decltype, но на данный момент у меня нет под рукой этого компилятора, чтобы убедиться, что он компилируется.

Если вам не нравится загрязнять ваше перечисление последним элементом COUNT (потому что, возможно, если вы также используете перечисление в переключателе, тогда компилятор предупредит вас об отсутствующем регистре COUNT :), вы можете сделать это:

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

Если бы вы знали, что значения перечисления были последовательными, например перечисление Qt: Key, вы могли бы:

Qt::Key shortcut_key = Qt::Key_0;
for (int idx = 0; etc...) {
    ....
    if (shortcut_key <= Qt::Key_9) {
        fileMenu->addAction("abc", this, SLOT(onNewTab()),
                            QKeySequence(Qt::CTRL + shortcut_key));
        shortcut_key = (Qt::Key) (shortcut_key + 1);
    }
}

Работает как положено.

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

    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 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 < E_Last; i = EAnimalCaps(i << 1))
    {}

Просто создайте массив целых чисел и выполните цикл по массиву, но сделайте последний элемент равным -1 и используйте его для условия выхода.

Если перечисление:

enum MyEnumType{Hay=12,Grass=42,Beer=39};

затем создайте массив:

int Array[] = {Hay,Grass,Beer,-1};

for (int h = 0; Array[h] != -1; h++){
  doStuff( (MyEnumType) Array[h] );
}

Это не нарушается независимо от целых чисел в представлении, если, конечно, проверка -1 не сталкивается с одним из элементов.

Вот еще одно решение, которое работает только для непрерывных перечислений. Он дает ожидаемую итерацию, за исключением уродства в приращении, которому он и принадлежит, поскольку это то, что сломано в C++.

enum Bar {
    One = 1,
    Two,
    Three,
    End_Bar // Marker for end of enum; 
};

for (Bar foo = One; foo < End_Bar; foo = Bar(foo + 1))
{
    // ...
}

enum class A {
    a0=0, a3=3, a4=4
};
constexpr std::array<A, 3> 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 << static_cast<int>(a);
}

constexpr std::array может перебирать даже непоследовательные перечисления без создания экземпляра массива компилятором. Это зависит от таких вещей, как эвристика оптимизации компилятора и от того, берете ли вы адрес массива.

В своих экспериментах я обнаружил, что g++ 9.1 с -O3 оптимизирует указанный выше массив, если есть 2 непоследовательных значения или довольно много последовательных значений (я тестировал до 6). Но это происходит только в том случае, если у вас есть инструкция if. (Я пробовал оператор, который сравнивал целочисленное значение, превышающее все элементы в последовательном массиве, и он встроил итерацию, несмотря на то, что ни один из них не был исключен, но когда я оставил оператор if, значения были помещены в память.) Он также встроил 5 значения из непоследовательного перечисления в [один случай | https://godbolt.org/z/XuGtoc]. Я подозреваю, что такое странное поведение связано с глубокой эвристикой, связанной с кешами и предсказанием ветвлений.

Вот ссылка на простую итерацию теста на Godbolt, который демонстрирует, что массив не всегда создается.

Цена этого метода состоит в том, чтобы дважды написать элементы перечисления и синхронизировать два списка.

Предположение, что перечисление пронумеровано последовательно, подвержено ошибкам. Более того, вы можете захотеть перебрать только выбранные перечислители. Если это подмножество невелико, явный цикл по нему может быть элегантным выбором:

enum Item { Man, Wolf, Goat, Cabbage }; // or enum class

for (auto item : {Wolf, Goat, Cabbage}) { // or Item::Wolf, ...
    // ...
}

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 < EnumLength; i++){
    //Do something with enumItems[i]
}

В книге Бьярна Страуструпа по языку программирования C++ вы можете прочитать, что он предлагает перегрузить operator++ для вашего конкретного enum. enum - это типы, определяемые пользователем, и для этих конкретных ситуаций в языке существует оператор перегрузки.

Вы сможете закодировать следующее:

#include <iostream>
enum class Colors{red, green, blue};
Colors& operator++(Colors &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 << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    return 0;
}

код теста: http://cpp.sh/357gb

Учтите, что я использую enum class. Код также отлично работает с enum. Но я предпочитаю enum class, поскольку они строго типизированы и могут предотвратить ошибку во время компиляции.

Расширение ответа @ Eponymous: это здорово, но не дает общего синтаксиса. Вот что я придумал:

// Common/EnumTools.h
#pragma once

#include <array>

namespace Common {

// Here we forward-declare metafunction for mapping enums to their values.
// Since C++<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&, Commob::EnumAllValuesTag) { return std::array{E::foo, E::bar}; }
// Then `AllValues<NS::E>` 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: "for (auto val : Common::AllValues<MyEnum>) {"

struct EnumAllValuesTag {}; // So your allValuesArray function is clearly associated with this header.

template <typename Enum>
static inline constexpr auto AllValues = allValuesArray(Enum{}, EnumAllValuesTag{});
// ^ Just "constexpr auto" or "constexpr std::array<Enum, allValuesArray(Enum{}, EnumAllValuesTag{}).size()>" didn't work on all compilers I'm using, but this did.

} // namespace Common

затем в вашем пространстве имен:

#include "Common/EnumTools.h"

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&, Common::EnumAllValuesTag) {
    return std::array{ MyEnum::foo, MyEnum::bar, MyEnum::baz };
}

} // namespace MyNamespace

затем везде, где вам нужно его использовать:

for (const auto& e : Common::AllValues<MyNamespace::MyEnum>) { ... }

так что даже если вы напечатали:

namespace YourNS {
using E = MyNamespace::MyEnum;
} // namespace YourNS

for (const auto& e : Common::AllValues<YourNS::E>) { ... }

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

Будущая работа:

1. Вы должны иметь возможность добавить функцию constexpr (и, следовательно, метафункцию), которая фильтрует Common::AllValues<E>, чтобы предоставить Common::AllDistinctValues<E> для случая перечислений с повторяющимися числовыми значениями, например enum { foo = 0, bar = 0 };.
2. Бьюсь об заклад, есть способ использовать switch-Covers-all-enum-values ​​компилятора для записи allValuesArray, что приведет к ошибке, если перечисление добавило значение.

Плюсы: перечисления могут иметь любые значения, которые вам нравятся, в любом порядке, и их по-прежнему легко перебирать. Имена и значения определяются один раз в первом #define.

Минусы: если вы используете это на работе, вам понадобится целый абзац, чтобы объяснить это вашим коллегам. И раздражает необходимость объявлять память, чтобы дать вашему циклу что-то для итерации, но я не знаю обходного пути, который не ограничивал бы вас перечислениями со смежными значениями (и если перечисление всегда будет иметь смежные значения, В любом случае enum может не так уж много вам покупать.)

//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 << d;
  for (auto z : myWalkableEnum)
    std::cout << z;
}
//outputs 70567

Уловка объявления списка с неопределенной оболочкой макроса и последующего определения оболочки по-разному в различных ситуациях имеет много других приложений, кроме этого.

Большинство решений основаны на циклах в диапазоне (MIN, MAX), но не учитывают тот факт, что в перечислении могут быть дыры.

Мои предложения:

        for (int i = MYTYPE_MIN; i <= MYTYPE_MAX; i++) {
            if (MYTYPE_IsValid(i)) {
                MYTYPE value = (MYTYPE)i;
                // DoStuff(value)
            }   
        }