¿Por qué no puedo incrementar una variable de un tipo enumerado?

Question

Tengo un tipo enumerado StackID, y estoy usando la enumeración para referirme a un índice de un vector particular y hace que mi código sea más fácil de leer. Sin embargo, ahora necesito crear una variable llamada nextAvail de tipo StackID. (en realidad se refiere a un stackID particular). Traté de incrementarlo pero en C++, el siguiente es ilegal:

nextAvail++; 

¿Qué tipo de sentido para mí ... porque no hay comprobación de límites.

Probablemente esté pasando por alto algo obvio, pero ¿cuál es un buen sustituto?

---

También quiero hacer un enlace a this pregunta.

Answer 1

Probablemente estoy pasando por alto algo obvio, pero ¿cuál es un buen sustituto?

Sobrecarga operator++:

// Beware, brain-compiled code ahead! 
StackID& operator++(StackID& stackID) 
{ 
#if MY_ENUMS_ARE_CONTIGUOUS && I_DO_NOT_WORRY_ABOUT_OVERFLOW 
    return stackID = static_cast<StackID>(++static_cast<int>(stackID)); 
#else 
    switch(stackID) { 
    case value1 : return stackID = value2; 
    case value2 : return stackID = value3; 
    ... 
    case valueN : return stackID = value1; 
    } 
    assert(false); 
    return stackID; // some compilers might warn otherwise 
#endif 
} 

StackID operator++(StackID& stackID, int) 
{ 
    StackID tmp(stackID); 
    ++stackID; 
    return tmp; 
} 

Answer 2

Se supone que una enumeración semántica representa un conjunto de valores relacionados distintos.

lo que podría tener

enum Colour {RED, GREEN, BLUE}; 

Pero eso debe ser equivalente a:

enum Colour {GREEN, BLUE, RED}; 

El problema es que si incrementas una enumeración entonces esas representaciones no son los mismos. GREEN ++ en el primer caso no es lo mismo que GREEN ++ en el segundo.

Hacer que su programa dependa de la declaración de la enumeración es una receta para desastres: los encargados del mantenimiento pueden suponer que el orden de la enumeración no importa, introduciendo muchos errores silenciosos.

Answer 3

Las enumeraciones van a ser tipo int, por lo que puede emitirlas. ¿Es esto lo que estás tratando de hacer?

int ndx = (int) StackID.SomeValue; 
... 
++ndx; 

Esto hará que alguien esté muy confundido en la línea, por supuesto.

Se me ocurre que está usando un enum donde debe usar const, o incluso #define. enum es más apropiado cuando tiene valores arbitrarios (donde el valor exacto no es significativo).

Answer 4

casting de ida y vuelta a/desde int es, por supuesto, la solución obvia, entonces dejar en claro que entiende que la adición está sucediendo "fuera" de la enum:

nextAvail = static_cast<StackID>(static_cast<int>(nextAvail) + 1); 

Answer 5

Con respecto a oprator ++, $ 5.2 .6/1 dice: "El tipo de operando debe ser un tipo aritmético o un puntero a un tipo de objeto completo".

StackID no encaja aquí. Es del tipo enumeración.

Una opción es la siguiente

$ 5.7/1 - "Además, ambos operandos tendrán un tipo de enumeración o aritmética, o un operando será un puntero a un tipo de objeto completamente definido y el otro tendrá un tipo de enumeración o integral".

enum Possibility {Yes, No, Maybe}; 

Possibility operator++(Possibility const& r){ 
    return Possibility(r + 1); // convert r to integer, add 1, convert back to Enum 
} 

int main(){ 
    Possibility p = Yes; 
    Possibility p1 = ++p; 
} 

Answer 6

Porque las enumeraciones no tienen que ser contiguas. P.ej. tome este ejemplo:

enum Colors { 
cRed, // = 0 
cBlue, // = 1 
cGreen = 3 
} 

¿Qué debería pasar en este escenario?

Colors color = cBlue; 
Colors other = color++; 

Debería haber otra cGreen o debe ser 2. En ese caso, no es un miembro de la enumeración válida más. ¿Qué hay de esto?

Colors color = cGreen; 
Colors other = color++; 

En caso de ser othercRed (envolver) o 4?

Como puede ver, poder incrementar los valores de enumeración introduce un montón de preguntas y complica el mecanismo simple que pretenden ser.

Si todo lo que te preocupa es el valor entero que se incrementa, entonces simplemente transfórmalo a int e incrementa eso.

Answer 7

¿Por qué no almacenar nextAvail en su lugar como int si va a hacer operaciones aritméticas en él?

Otra opción sería envolver la enumeración en su propio tipo y sobrecargar operator ++ (que también podría envolver o algo así por ejemplo).