Come posso iterare su un enum?

Ho appena notato che non è possibile utilizzare operatori matematici standard su un enum come ++ o + =

Quindi qual è il modo migliore per scorrere tutti i valori in un enumerazione C ++?

Il modo tipico è il seguente:

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

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

Si noti che l'enum Lastdeve essere ignorato dall'iterazione. Utilizzando questo Lastenum "falso" , non è necessario aggiornare la propria condizione di terminazione nel ciclo for all'ultimo enum "reale" ogni volta che si desidera aggiungere un nuovo enum. Se vuoi aggiungere più enumerazioni in un secondo momento, aggiungile prima di Last. Il ciclo in questo esempio continuerà a funzionare.

Naturalmente, questo si interrompe se vengono specificati i valori enum:

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

Ciò dimostra che un enum non è realmente destinato a scorrere. Il modo tipico di gestire un enum è usarlo in un'istruzione 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 vuoi davvero enumerare, riempi i valori enum in un vettore e ripeti quello. Questo tratterà correttamente anche i valori enum specificati.

#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 la tua enum inizia con 0 e l'incremento è sempre 1.

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

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

Altrimenti credo che l'unico motivo sia creare qualcosa di simile a

vector<enumType> vEnums;

aggiungi gli elementi e usa i normali iteratori ....

Con c ++ 11 esiste effettivamente un'alternativa: scrivere un semplice iteratore personalizzato basato su modelli.

supponiamo che sia il tuo enum

enum class foo {
  one,
  two,
  three
};

Questo codice generico farà il trucco, in modo abbastanza efficiente - posizionalo in un'intestazione generica, ti servirà per qualsiasi enum di cui potresti aver bisogno per scorrere:

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

Dovrai specializzarlo

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

E poi puoi iterare usando range-for

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

L'ipotesi che tu non abbia lacune nel tuo enum è ancora vera; non si presuppone il numero di bit effettivamente necessari per memorizzare il valore enum (grazie a std :: sottostanti_tipo)

troppo complicata questa soluzione, mi piace che:

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

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

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

Lo faccio spesso così

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

o se non successivo, ma con passo regolare (ad es. bit flag)

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

Non puoi con un enum. Forse un enum non è la soluzione migliore per la tua situazione.

Una convenzione comune è quella di nominare l'ultimo valore enum qualcosa come MAX e usarlo per controllare un loop usando un int.

Qualcosa che non è stato trattato nelle altre risposte = se stai usando enumerazioni C ++ 11 fortemente tipizzate, non puoi usarle ++o + intsu di esse. In tal caso, è necessaria una soluzione un po 'più complicata:

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)

}

Puoi provare a definire la seguente 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))

Ora puoi usarlo:

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

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

Può essere utilizzato per scorrere avanti e indietro tra unsigned, interi, enum e caratteri:

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


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

Nonostante la sua definizione scomoda, è ottimizzato molto bene. Ho osservato il disassemblatore in VC ++. Il codice è estremamente efficiente. Non rimandare ma le tre dichiarazioni: il compilatore produrrà solo un ciclo dopo l'ottimizzazione! Puoi persino definire loop chiusi:

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

Ovviamente non puoi iterare attraverso tipi enumerati con lacune.

È inoltre possibile sovraccaricare gli operatori di incremento / decremento per il tipo elencato.

Supponendo che l'enum sia numerato in sequenza, è soggetto a errori. Inoltre, potresti voler iterare solo su enumeratori selezionati. Se quel sottoinsieme è piccolo, passarci sopra esplicitamente potrebbe essere una scelta elegante:

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

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

Se non ti piace inquinare la tua enum con un oggetto COUNT finale (perché forse se usi anche l'enum in uno switch allora il compilatore ti avvertirà di un caso COUNT mancante :), puoi farlo:

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

Ecco un'altra soluzione che funziona solo per enigmi contigui. Fornisce l'iterazione prevista, ad eccezione della bruttezza nell'incremento, che è dove appartiene, dal momento che è ciò che è rotto in 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);
}

UN constexpr std::array può iterare anche enumerazioni non sequenziali senza che l'array sia istanziato dal compilatore. Questo dipende da cose come l'euristica dell'ottimizzazione del compilatore e dal fatto che tu prenda l'indirizzo dell'array.

Nei miei esperimenti, ho scoperto che g++9.1 con -O3ottimizzerà l'array sopra se ci sono 2 valori non sequenziali o parecchi valori sequenziali (ho testato fino a 6). Ma lo fa solo se hai una ifdichiarazione. (Ho provato un'istruzione che ha confrontato un valore intero maggiore di tutti gli elementi in un array sequenziale e ha incorporato l'iterazione nonostante nessuno sia stato escluso, ma quando ho lasciato fuori l'istruzione if, i valori sono stati messi in memoria.) Ha anche sottolineato 5 valori da un enum non sequenziale in [un caso | https://godbolt.org/z/XuGtoc] . Sospetto che questo strano comportamento sia dovuto alla profonda euristica che ha a che fare con la cache e la previsione del ramo.

Ecco un link a una semplice iterazione di prova su godbolt che dimostra che l'array non viene sempre istanziato.

Il prezzo di questa tecnica sta scrivendo gli elementi enum due volte e mantenendo sincronizzati i due elenchi.

Nel libro del linguaggio di programmazione C ++ di Bjarne Stroustrup, puoi leggere che sta proponendo di sovraccaricare il operator++tuo specifico enum. enumsono tipi definiti dall'utente e l'operatore di overload esiste nella lingua per queste situazioni specifiche.

Sarai in grado di codificare quanto segue:

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

codice di prova: http://cpp.sh/357gb

Ricorda che sto usando enum class. Il codice funziona bene enumanche con . Ma preferisco enum classpoiché sono fortemente tipizzati e possono impedirci di fare errori in fase di compilazione.

Per compilatori 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: questo è molto meno codice rispetto alla semplice risposta iteratrice personalizzata modellata.

Puoi farlo funzionare con GCC usando typeofinvece didecltype , ma al momento non ho quel compilatore a portata di mano per assicurarmi che si compili.

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

Il C ++ non ha introspezione, quindi non è possibile determinare questo tipo di cose in fase di esecuzione.

Se sapessi che i valori di enum erano sequenziali, ad esempio l'enumerazione Qt: Key, potresti:

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

Funziona come previsto.

Basta creare un array di ints e scorrere sull'array, ma fare in modo che l'ultimo elemento dica -1 e utilizzarlo per la condizione di uscita.

Se enum è:

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

quindi creare un array:

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

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

Ciò non si interrompe, indipendentemente dagli ints nella rappresentazione, purché il controllo -1 non si scontri con uno degli elementi ovviamente.