C++ obecnie nie udostępnia iteracji enumeratora. Mimo to czasami pojawia się taka potrzeba. Powszechnym obejściem jest dodawanie wartości oznaczających początek i koniec. Na przykład:

enum Color
{
    Color_Begin,
    Color_Red = Color_Begin,
    Color_Orange,
    Color_Yellow,
    Color_Green,
    Color_Blue,
    Color_Indigo,
    Color_Violet,
    Color_End
};

void foo(Color c)
{
}


void iterateColors()
{
    for (size_t colorIdx = Color_Begin; colorIdx != Color_End; ++colorIdx)
    {
        foo(static_cast<Color>(colorIdx));
    }
}

Nie jest to możliwe bez odrobiny pracy fizycznej. Wiele pracy można wykonać za pomocą makr, jeśli chcesz zagłębić się w ten obszar.

Rozszerzając to, co mówi Konrad, jednym z możliwych idiomów w przypadku "Generuj kod dla każdej iteracji" jest użycie dołączonego pliku do reprezentowania wyliczenia:

#ifndef LAST_ENUM_ELEMENT
#define LAST_ENUM_ELEMENT(ARG) ENUM_ELEMENT(ARG)
#endif

ENUM_ELEMENT(foo)
ENUM_ELEMENT(bar)
LAST_ENUM_ELEMENT(baz)

// not essential, but most likely every "caller" should do it anyway...
#undef LAST_ENUM_ELEMENT
#undef ENUM_ELEMENT

Enum.h:

// include guard goes here (but mystuff.h doesn't have one)

enum element {
    #define ENUM_ELEMENT(ARG) ARG,
    #define LAST_ENUM_ELEMENT(ARG) ARG
    #include "mystuff.h"
}

Main.cpp:

#include "enum.h"
#define ENUM_ELEMENT(ARG) void do_##ARG();
#include "mystuff.h"

element value = getValue();
switch(value) {
    #define ENUM_ELEMENT(ARG) case ARG: do_##ARG(); break;
    #include "mystuff.h"
    default: std::terminate();
}

Aby dodać nowy element "qux", należy dodać go do mystuff.h i zapisz funkcję do_qux. Nie musisz dotykać kodu.

Oczywiście, jeśli wartości w Twoim enum muszą być konkretnymi liczbami całkowitymi, wtedy kończysz zachowanie definicji enum i ENUM_ELEMENT(foo)... lista osobno, co jest niechlujne.

Nie

Możesz jednak zdefiniować własną klasę, która implementuje funkcje podobne do enum za pomocą iteracji. Możesz przypomnieć sobie sztuczkę z przed 1.5 dni Java, o nazwie "type safe enum design pattern". Możesz zrobić odpowiednik C++.

To wydaje mi się trudne, ale może pasować do Twoich celów:

enum Blah {
  FOO,
  BAR,
  NUM_BLAHS
};

// later on
for (int i = 0; i < NUM_BLAHS; ++i) {
  switch (i) {
  case FOO:
    // foo stuff
    break;
  case BAR:
    // bar stuff
    break;
  default:
    // you're missing a case statement
  }
}

Jeśli potrzebujesz specjalnej wartości początkowej, możesz ustawić ją jako stałą i ustawić w swoim enum. Nie sprawdzałem czy to kompiluje, ale powinno być blisko: -). Mam nadzieję, że to pomoże.

Myślę, że takie podejście może być dobrą równowagą dla Twojego przypadku użycia. Użyj go, jeśli nie musisz tego robić dla kilku różnych typów wyliczeń i nie chcesz zajmować się sprawami preprocesora. Tylko upewnij się, że komentujesz i prawdopodobnie dodaj TODO, aby zmienić go w późniejszym terminie na coś lepszego :-).

Zwykle robię to tak:

enum abc
{    
    abc_begin,
    a = abc_begin,
    b,
    c,
    abc_end
};

void foo()
{
    for( auto&& r : range(abc_begin,abc_end) )
    {
        cout << r;
    }
}

range jest całkowicie ogólny i zdefiniowany w następujący sposób:

template <typename T>
class Range
{
public:
    Range( const T& beg, const T& end ) : b(beg), e(end) {}
    struct iterator
    {
        T val;
        T operator*() { return val; }
        iterator& operator++() { val = (T)( 1+val ); return *this; }
        bool operator!=(const iterator& i2) { return val != i2.val; }
    };
    iterator begin() const { return{b}; }
    iterator end() const { return{e}; }
private:
    const T& b;
    const T& e;
};

template <typename T>
Range<T> range( const T& beg, const T& end ) { return Range<T>(beg,end); }

Można wykonywać niektóre z proponowanych technik runtime statycznie z TMP.

#include <iostream>

enum abc
{
    a,
    b,
    c,
    end
};

void function_call(abc val)
{
    std::cout << val << std::endl;
}

template<abc val>
struct iterator_t
{
    static void run()
    {
        function_call(val);

        iterator_t<static_cast<abc>(val + 1)>::run();
    }
};

template<>
struct iterator_t<end>
{
    static void run()
    {
    }
};

int main()
{
    iterator_t<a>::run();

    return 0;
}

Wyjście z tego programu to:

0
1
2

function_call(a);
function_call(b);
function_call(c);

Inline function_call dla jeszcze większej pomocy z kompilator.

Ta sama krytyka innych technik iteracji wyliczeń stosuje się tutaj. Ta technika działa tylko wtedy, gdy twoje wyliczenie wzrasta w sposób ciągły od A do końca przez jedynki.

Uwielbiam szablony, ale zamierzam zanotować to dla mojej przyszłości/wykorzystania innych ludzi, więc nie zgubimy się z żadnym z powyższych.

Wyliczenia są wygodne do porównywania rzeczy w znany uporządkowany sposób. Są one zwykle używane do kodowania na twardo w funkcjach w celu odczytania wartości całkowitych. Nieco podobne do definicji preprocesora, z tym wyjątkiem, że nie są one zastępowane literałami, ale przechowywane i dostępne w trybie runtime.

Gdybyśmy mieli enum definiowanie kodów błędów html i wiedzieliśmy, że kody błędów w 500s są błędami serwera, może być ładniej przeczytać coś w stylu:

enum HtmlCodes {CONTINUE_CODE=100,CLIENT_ERROR=400,SERVER_ERROR=500,NON_STANDARD=600};

if(errorCode >= SERVER_ERROR && errorCode < NON_STANDARD)

Niż

if(errorCode >= 500 && errorCode < 600)

Kluczową częścią jest to, że są one podobne do tablic! ale są używane do gipsowe wartości całkowite .

Krótki przykład:

enum Suit {Diamonds, Hearts, Clubs, Spades};
//does something with values in the enum past "Hearts" in this case
for(int i=0;i<4;i++){
   //Could also use i or Hearts, because the enum will turns these both back into an int 
   if( (Suit)(i) > 1 )
   {
      //Whatever we'd like to do with (Suit)(i)
   }
}

Często enums są również używane z tablicami char * lub tablicami łańcuchowymi, dzięki czemu można wydrukować wiadomość z powiązaną wartością. Normalnie są po prostu tablice z tym samym zestawem wartości w enum, jak tak:

char* Suits[4] = {"Diamonds", "Hearts", "Clubs", "Spades"};
//Getting a little redundant
cout << Suits[Clubs] << endl;
//We might want to add this to the above
//cout << Suits[(Suit)(i)] << endl;

I oczywiście jeszcze przyjemniej jest stworzyć klasę generyczną, która obsługuje iterację dla enum, jak w powyższych odpowiedziach.