¿Existe algún paradigma bien conocido para iterar los valores enum?

Question

tengo algo de código C++, en la que se declara la siguiente enumeración:

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

Los valores de Alfa, Beta y Gamma son secuenciales, y con mucho gusto utilizar el siguiente ciclo para iterar a través de ellos:

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

Este ciclo está bien, hasta que decida cambiar el orden de las declaraciones en la enumeración, por ejemplo, haciendo que Beta sea el primer valor y Alpha, el segundo. Eso invalida el encabezado del ciclo, porque ahora tengo que iterar de Beta a Total. Entonces, ¿cuáles son las mejores prácticas de iteración a través de enum? Quiero iterar a través de todos los valores sin cambiar los encabezados de ciclo cada vez. No puedo pensar en una solución:

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

e iterar a partir de (Start + 1) al total, pero parece feo y nunca he visto a alguien hacerlo en el código. ¿Existe algún paradigma bien conocido para iterar a través de la enumeración, o simplemente tengo que fijar el orden de los valores enum? (Vamos a suponer que, realmente tengo algunas razones impresionantes para cambiar el orden de los valores de enumeración) ...

Answer 1

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

Haciendo tal que pueda otorgar a primera & última nunca cambia para

Answer 2

Si no se utiliza ningún asignaciones, las enumeraciones están garantizadas para ser secuenciales comenzando con 0 como el primero. thers.

Lo mejor que puede hacer es mantenerlos en el orden que desee en su definición de enumeración, y recorrerlos con el ciclo for.

Answer 3

No, no hay manera de hacer esto porque no hay ninguna garantía de que alguien no ha escrito un código como:

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

Answer 4

Se puede extraer de este article con su source code de cómo se puede aplicar esto con miembros estáticos de la clase.

Answer 5

Coloque todos los mensajes en su propio espacio de nombres. Ejemplo:

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

En código:

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

Esto es debido a que C++ permite cosas como esta (no probado en un compilador):

enum Foo { 
Alpha = 1 
}; 

enum Bar { 
Beta = 2 
}; 

Foo foo = Beta; 

que está claramente equivocado.

Answer 6

Puede definir un operator++() para su enum. Esto tiene la ventaja de que utiliza el conocido paradigma de los operadores de incremento estándar. :)

Dependiendo de si sus enumeraciones son contiguos, puede tratarlos como int o usar un interruptor:

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 
} 

Tenga en cuenta que, si se ha definido operator++(), los usuarios probablemente esperar un operator--(), también.

Answer 7

En 11 (y probablemente antes), se puede utilizar este truco C++, para hacer Some iterable:

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

(esta pregunta sin pudor una adaptación de here.)