Jak mogę iterować po wyliczeniu?

Właśnie zauważyłem, że nie można używać standardowych operatorów matematycznych na wyliczeniu, takich jak ++ lub + =

Więc jaki jest najlepszy sposób na iterację wszystkich wartości w wyliczeniu C ++?

Typowy sposób jest następujący:

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

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

Uwaga: wyliczanie Lastma być pomijane przez iterację. Korzystając z tego „fałszywego” Lastwyliczenia, nie musisz aktualizować warunku zakończenia w pętli for do ostatniego „prawdziwego” wyliczenia za każdym razem, gdy chcesz dodać nowy wyliczenie. Jeśli chcesz dodać więcej wyliczeń później, po prostu dodaj je przed Ostatnim. Pętla w tym przykładzie nadal będzie działać.

Oczywiście to się psuje, jeśli określono wartości wyliczeniowe:

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

To pokazuje, że wyliczenie nie jest tak naprawdę przeznaczone do iteracji. Typowym sposobem radzenia sobie z wyliczeniem jest użycie go w instrukcji switch.

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

Jeśli naprawdę chcesz wyliczyć, umieść wartości wyliczenia w wektorze i powtórz to. To również odpowiednio poradzi sobie z określonymi wartościami wyliczania.

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

Jeśli twoje wyliczenie zaczyna się od 0, a przyrost wynosi zawsze 1.

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

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

Jeśli nie, myślę, że jedynym powodem jest stworzenie czegoś takiego

vector<enumType> vEnums;

dodaj elementy i użyj zwykłych iteratorów ....

W wersji c ++ 11 istnieje alternatywa: napisanie prostego niestandardowego iteratora opartego na szablonie.

załóżmy, że twój enum jest

enum class foo {
  one,
  two,
  three
};

Ten ogólny kod wykona tę sztuczkę, dość skutecznie - umieść w ogólnym nagłówku, będzie ci służył do każdego wyliczenia, które może być konieczne do iteracji:

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

Musisz go specjalizować

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

A potem możesz iterować za pomocą zasięgu

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

Założenie, że nie masz luk w swoim wyliczeniu, jest nadal prawdziwe; nie ma założenia co do liczby bitów faktycznie potrzebnych do przechowywania wartości wyliczeniowej (dzięki std :: bazowy_typ)

zbyt skomplikowane te rozwiązania, lubię to:

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

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

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

Często tak robię

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

lub jeśli nie sukcesywnie, ale z regularnym krokiem (np. flagi bitowe)

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

Nie możesz wyliczyć. Może wyliczenie nie najlepiej pasuje do twojej sytuacji.

Powszechną konwencją jest nazywanie ostatniej wartości wyliczenia czegoś takiego jak MAX i używanie jej do sterowania pętlą za pomocą int.

Coś, co nie zostało uwzględnione w innych odpowiedziach = jeśli używasz silnie napisanych wyliczeń C ++ 11, nie możesz ich używać ++ani + intna nich. W takim przypadku wymagane jest trochę bałaganu:

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)

}

Możesz spróbować zdefiniować następujące makro:

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

Teraz możesz go użyć:

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

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

Można go używać do iteracji w przód i w tył przez bez znaku, liczby całkowite, wyliczenia i znaki:

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


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

Pomimo niezręcznej definicji jest bardzo dobrze zoptymalizowany. Patrzyłem na deasembler w VC ++. Kod jest niezwykle wydajny. Nie zniechęcaj się, ale trzy instrukcje: kompilator wygeneruje tylko jedną pętlę po optymalizacji! Możesz nawet zdefiniować zamknięte pętle:

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

Oczywiście nie można iterować po wyliczonych typach z lukami.

Można także przeciążać operatory inkrementacji / dekrementacji dla wyliczonego typu.

Zakładanie, że wyliczenie jest kolejno numerowane, jest podatne na błędy. Ponadto możesz iterować tylko nad wybranymi modułami wyliczającymi. Jeśli ten podzbiór jest mały, wyraźne zapętlenie może być eleganckim wyborem:

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

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

Jeśli nie chcesz zanieczyszczać swojego wyliczenia końcowym elementem COUNT (ponieważ być może, jeśli użyjesz również wyliczenia w przełączniku, wtedy kompilator ostrzeże Cię o brakującej liczbie przypadków COUNT :), możesz to zrobić:

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

Oto inne rozwiązanie, które działa tylko dla ciągłych wyliczeń. Daje oczekiwaną iterację, z wyjątkiem brzydoty w przyroście, do której należy, ponieważ to właśnie jest zepsute w 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::arraymoże iterować nawet niesekwencyjne wyliczenia bez tworzenia instancji tablicy przez kompilator. Zależy to od heurystyki optymalizacyjnej kompilatora i od tego, czy weźmiesz adres tablicy.

W moich eksperymentach odkryłem, że g++9.1 z -O3zoptymalizuje powyższą tablicę, jeśli są 2 wartości niesekwencyjne lub całkiem kilka wartości sekwencyjnych (testowałem do 6). Ale robi to tylko wtedy, gdy masz ifoświadczenie. (Próbowałem instrukcji, która porównała liczbę całkowitą większą niż wszystkie elementy w tablicy sekwencyjnej i podniosła iterację, mimo że żadna nie została wykluczona, ale kiedy pominąłem instrukcję if, wartości zostały zapisane w pamięci.) wartości z niesekwencyjnego wyliczenia w [jednym przypadku | https://godbolt.org/z/XuGtoc] . Podejrzewam, że to dziwne zachowanie wynika z głębokiej heurystyki związanej z pamięcią podręczną i prognozowaniem gałęzi.

Oto link do prostej iteracji testu na godbolt, która pokazuje, że tablica nie zawsze jest tworzona .

Cena tej techniki polega na dwukrotnym zapisaniu elementów wyliczeniowych i zsynchronizowaniu dwóch list.

W książce języka programowania C ++ Bjarne'a Stroustrupa możesz przeczytać, że proponuje on przeciążenie operator++twojego specyficznego enum. enumsą typami zdefiniowanymi przez użytkownika, a operator przeciążenia istnieje w języku dla tych konkretnych sytuacji.

Możesz kodować następujące elementy:

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

kod testowy: http://cpp.sh/357gb

Pamiętaj, że używam enum class. Kod działa enumrównież dobrze z . Ale wolę, enum classponieważ są dobrze napisane i mogą zapobiec popełnieniu błędu w czasie kompilacji.

W przypadku kompilatorów 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); 
}

Uwaga: jest to o wiele mniej kodu niż prosta niestandardowa odpowiedź iteratora z szablonu.

Możesz sprawić, aby działał z GCC, używając typeofzamiast niego decltype, ale w tej chwili nie mam tego kompilatora, aby się upewnić, że się skompiluje.

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 ++ nie ma introspekcji, więc nie można tego określić w czasie wykonywania.

Jeśli wiesz, że wartości wyliczenia są sekwencyjne, na przykład wyliczanie Qt: Key, możesz:

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

Działa zgodnie z oczekiwaniami.

Po prostu utwórz tablicę liczb całkowitych i zapętl ją nad tablicą, ale spraw, aby ostatni element powiedział -1 i użyj go jako warunku wyjścia.

Jeśli wyliczeniem jest:

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

następnie utwórz tablicę:

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

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

Nie rozkłada się to bez względu na ints w reprezentacji, o ile kontrola -1 nie koliduje z jednym z elementów.