Como posso iterar sobre uma enumeração?

Acabei de notar que você não pode usar operadores matemáticos padrão em uma enumeração como ++ ou + =

Então, qual é a melhor maneira de iterar todos os valores em uma enumeração C ++?

A maneira típica é a seguinte:

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

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

Observe que o enum Lastdeve ser ignorado pela iteração. Utilizando essa Lastenumeração "falsa" , você não precisa atualizar sua condição final no loop for para a última enumeração "real" toda vez que desejar adicionar uma nova enumeração. Se você quiser adicionar mais enumerações posteriormente, basta adicioná-las antes do Último. O loop neste exemplo ainda funcionará.

Obviamente, isso será interrompido se os valores de enumeração forem especificados:

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

Isso ilustra que um enum não é realmente destinado a iterar. A maneira típica de lidar com uma enumeração é usá-la em uma instrução switch.

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

Se você realmente deseja enumerar, encha os valores de enum em um vetor e itere sobre ele. Isso também lidará adequadamente com os valores de enum especificados.

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

Se o seu enum começa com 0 e o incremento é sempre 1.

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

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

Se não, acho que o único motivo é criar algo como um

vector<enumType> vEnums;

adicione os itens e use iteradores normais ....

Com o c ++ 11, na verdade existe uma alternativa: escrever um iterador personalizado simples e com modelo.

vamos assumir que seu enum é

enum class foo {
  one,
  two,
  three
};

Esse código genérico fará o truque, com bastante eficiência - coloque em um cabeçalho genérico, servirá para qualquer enumeração que você precise repetir:

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

Você precisará se especializar

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

E então você pode iterar usando o intervalo para

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

A suposição de que você não tem lacunas na enumeração ainda é verdadeira; não há suposição sobre o número de bits realmente necessário para armazenar o valor da enumeração (graças a std :: subjac_type)

muito complicado essas soluções, eu faço assim:

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

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

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

Costumo fazer assim

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

ou se não for sucessivo, mas com etapa regular (por exemplo, sinalizadores de bit)

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

Você não pode com um enum. Talvez um enum não seja o mais adequado para sua situação.

Uma convenção comum é nomear o último valor da enumeração como MAX e usá-lo para controlar um loop usando um int.

Algo que não foi abordado nas outras respostas = se você estiver usando enumerações C ++ 11 fortemente tipadas, não poderá usá -las ++ou + intnelas. Nesse caso, é necessária uma solução um pouco mais bagunçada:

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)

}

Você pode tentar definir a seguinte 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))

Agora você pode usá-lo:

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

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

Pode ser usado para iterar para frente e para trás através de números inteiros, enumerados e enumerados não assinados:

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


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

Apesar de sua definição incômoda, ele é otimizado muito bem. Eu olhei desmontador em VC ++. O código é extremamente eficiente. Não desanime, mas as três instruções for: o compilador produzirá apenas um loop após a otimização! Você pode até definir loops fechados:

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

Você obviamente não pode iterar por tipos enumerados com lacunas.

Você também pode sobrecarregar os operadores de incremento / decremento para seu tipo enumerado.

Assumir que o enum é numerado sequencialmente é propenso a erros. Além disso, convém iterar apenas sobre enumeradores selecionados. Se esse subconjunto for pequeno, fazer um loop sobre ele explicitamente pode ser uma escolha elegante:

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

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

Se você não gosta de poluir sua enumeração com um item COUNT final (porque talvez se você também usar a enumeração em um comutador, o compilador avisará sobre um caso ausente COUNT :), você pode fazer o seguinte:

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

Aqui está outra solução que funciona apenas para enumerações contíguas. Ele fornece a iteração esperada, exceto a feiura no incremento, que é o lugar a que pertence, pois é isso que está quebrado no 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);
}

A constexpr std::arraypode iterar até enumerações não sequenciais sem que a matriz seja instanciada pelo compilador. Isso depende de coisas como as heurísticas de otimização do compilador e se você usa o endereço da matriz.

Nas minhas experiências, descobri que o g++9.1 com -O3otimizará a matriz acima se houver 2 valores não sequenciais ou alguns valores sequenciais (testei até 6). Mas isso só acontece se você tiver uma ifdeclaração. (Tentei uma instrução que comparava um valor inteiro maior que todos os elementos em uma matriz seqüencial e ela delineava a iteração apesar de nenhuma ser excluída, mas quando deixei de fora a instrução if, os valores foram colocados na memória.) valores de uma enumeração não sequencial em [um caso | https://godbolt.org/z/XuGtoc] . Suspeito que esse comportamento estranho se deva a heurísticas profundas relacionadas a caches e previsão de ramificação.

Aqui está um link para uma iteração de teste simples no godbolt que demonstra que o array nem sempre é instanciado.

O preço dessa técnica é escrever os elementos da enumeração duas vezes e manter as duas listas sincronizadas.

No livro de linguagem de programação C ++ de Bjarne Stroustrup, você pode ler que ele está propondo sobrecarregar o operator++específico enum. enumsão tipos definidos pelo usuário e o operador de sobrecarga existe no idioma para essas situações específicas.

Você poderá codificar o seguinte:

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

código de teste: http://cpp.sh/357gb

Mente que estou usando enum class. Código funciona bem com enumtambém. Mas eu prefiro, enum classpois eles são de tipo forte e podem nos impedir de cometer erros no momento da compilação.

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

Nota: esse código é muito menos do que a resposta simples do iterador personalizado com modelo.

Você pode fazer isso funcionar com o GCC usando em typeofvez de decltype, mas não tenho esse compilador à mão no momento para garantir que ele seja compilado.

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

Como o C ++ não possui introspecção, não é possível determinar esse tipo de coisa em tempo de execução.

Se você soubesse que os valores da enumeração eram seqüenciais, por exemplo, a enumeração Qt: Key, você poderia:

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

Funciona como esperado.

Apenas faça uma matriz de entradas e faça um loop sobre a matriz, mas faça o último elemento dizer -1 e use-o para a condição de saída.

Se enum for:

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

então crie uma matriz:

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

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

Isso não se decompõe, independentemente das entradas na representação, desde que a verificação -1 não colide com um dos elementos, é claro.