Esiste un paradigma noto per iterare i valori enum?

Question

Ho qualche codice C++, in cui viene dichiarato il seguente enum:

enum Some 
{ 
    Some_Alpha = 0, 
    Some_Beta, 
    Some_Gamma, 
    Some_Total 
}; 
int array[Some_Total]; 

I valori di Alpha, Beta e Gamma sono sequenziali, e volentieri utilizzare il seguente ciclo per scorrere attraverso di loro:

for (int someNo = (int)Some_Alpha; someNo < (int)Some_Total; ++someNo) {} 

Questo ciclo va bene, fino a quando decido di cambiare l'ordine delle dichiarazioni nell'enum, diciamo, rendendo Beta il primo valore e Alpha - il secondo. Ciò invalida l'intestazione del ciclo, perché ora devo ripetere da Beta a Total. Quindi, quali sono le migliori pratiche per iterare con enum? Voglio scorrere tutti i valori senza modificare le intestazioni del ciclo ogni volta. Mi viene in mente una soluzione:

enum Some 
{ 
    Some_Start = -1, 
    Some_Alpha, 
    ... 
    Some_Total 
}; 
int array[Some_Total]; 

e iterare da (Start + 1) al totale, ma sembra brutto e non ho mai visto qualcuno che fa nel codice. C'è qualche paradigma noto per iterare attraverso l'enum, o devo solo fissare l'ordine dei valori enum? (Facciamo finta, ho davvero alcune ragioni impressionante per cambiare l'ordine dei valori enum) ...

Answer 1

enum Some 
{ 
    Some_first_ = 0, 
    Some_Alpha = Some_first_, 
.... 
    Some_last_ 
}; 

Facendo quali è possibile concedere prima & ultimo non cambia mai fine

Answer 2

Se non si utilizza qualsiasi assegnazioni, l'enumerazione è garantita come sequenziale a partire da 0 come prima. thers.

La cosa migliore che puoi fare è tenerli nell'ordine che vuoi nella definizione enum, e scorrere attraverso di essi con il ciclo for.

Answer 3

No, non c'è modo di fare questo perché non v'è alcuna garanzia che qualcuno non ha scritto il codice come:

enum Some 
{ 
    Some_Alpha = 0, 
    Some_Beta, 
    Some_Gamma = 42, 
    Some_Delta, 
    Some_Total 
}; 

Answer 4

È possibile controllare questo article con la sua source code su come è possibile implementare questo con membri della classe statici.

Answer 5

Posiziono tutte le enumerazioni nel proprio spazio dei nomi. Esempio:

namespace Foo { 
enum Enum { 
    First=0, // must be sequential 
    Second, 
    Third, 
    End // must be last 
}; 
} 

in codice:

for (int i=Foo::First; i!=Foo::End; i++) { 
// do stuff 
} 

Questo perché C++ permette cose come questa (non testato in un compilatore):

enum Foo { 
Alpha = 1 
}; 

enum Bar { 
Beta = 2 
}; 

Foo foo = Beta; 

che è chiaramente sbagliata.

Answer 6

È possibile definire un operator++() per il proprio enum. Questo ha il vantaggio di utilizzare il ben noto paradigma degli operatori di incremento standard. :)

seconda che i enumerazioni sono contigue, è possibile trattarli come int o utilizzare un interruttore:

Some& operator++(Some& obj) 
{ 
# if YOUR_ENUMS_ARE_CONTIGUOUS 
    int i = obj; 
    if(++i > Some_Total) i = Some_Alpha; 
    return obj = static_cast<Some>(i); 
# else 
    switch(obj) 
    { 
    case Some_Alpha : obj = Some_Beta; break; 
    case Some_Beta : obj = Some_Gamma; break; 
    case Some_Gamma : obj = Some_Total; break; 
    case Some_Total : obj = Some_Alpha; break; 
    default: assert(false); // changed enum but forgot to change operator 
    } 
    return obj; 
# endif 
} 

Si noti che, se operator++() è definito, gli utenti probabilmente si aspettano un operator--(), anche.

Answer 7

In C++ 11 (e probabilmente prima), è possibile utilizzare il seguente hack, per rendere Some iterabile:

Some operator++(Some& s) { 
    return s = (Some)(std::underlying_type<Some>::type(x) + 1); 
} 
Some operator*(Some s) { 
    return s; 
} 
Some begin(Some s) { 
    return Some_Alpha; 

Some end(Some s) { 
    return Some_Gamma; 
} 

int main() { 
    // the parenthesis here instantiate the enum 
    for(const auto& s : Some()) { 
     // etc. etc. 
    } 
    return 0; 
} 

(Questa risposta è stata spudoratamente adattato da here.)