¿Cómo verificar si una variable enum es válida?

Question

tengo una enumeración:

enum myenum{ 
    typeA, 
    typeB, 
    typeC 
} myenum_t; 

Entonces, funciona una es para ser llamado con un parámetro de enumeración:

int myfunction(myenum_t param1) 
{ 
    switch(param1) 
    { 
    case typeA: 
    case typeB: 
    case typeC: 
     //do the work 
     break; 

    default: 
     printf("Invalid parameter"); 
    } 
    return 0; 
} 

Pero, como myenum_t crece con más y más valores, myfunction no parece muy elegante.

¿Existe alguna forma mejor de verificar si una enumeración es válida o no?

Answer 1

Una convención común para esto es hacer algo como esto:

typedef enum { 
    typeA, 
    typeB, 
    typeC, 
    num_types 
} myenum_t; 

entonces usted puede comprobar para (t < num_types).

Si posteriormente agrega más enumeraciones, p.

typedef enum { 
    typeA, 
    typeB, 
    typeC, 
    typeD, 
    typeE, 
    num_types 
} myenum_t; 

continuación num_types se actualiza automáticamente y su código de comprobación de errores no tiene que cambiar.

Answer 2

Sí.

Deje que el compilador haga su trabajo, no eche int a un tipo enum y debe ser bueno.

Answer 3

se puede utilizar una enumeración bit a bit:

enum myEnum { 
    typeA = 1 << 0; 
    typeB = 1 << 1; 
    typeC = 1 << 2; 
} 

int myFunction(myEnum arg1) 
{ 
    int checkVal = typeA | typeB | typeC; 

    if (checkVal & arg1) 
    { 
     // do work here; 
    } 
    else 
    { 
     printf("invalid argument!"); 
    } 

    return 0; 
} 

Disculpe, parece haber leído mal la pregunta.

Parece que lo que quiere hacer es determinar si ha pasado un valor adecuado, no alguna opción inválida al azar. En ese caso, la opción más lógica es la siguiente:

if (arg1 < typeA || arg1 > typeC) 
    printf("invalid argument"); 

Esto es, por supuesto, asumiendo que no establece valores manuales para su enumeración, el cual, es bastante raro a menos que use enumeraciones bit a bit.

Answer 4

No se puede también hacer algo como

enum myEnum {typeA,typeB, typeC}; 

int myFunction (myEnum arg1) { 
    if (arg1 >= typeA && arg1 <= typeC) { 
     // do work here 
    } else { 
     printf("invalid argument!"); 
    } 
    return 0; 
} 

Answer 5

Desafortunadamente no hay una forma sencilla de hacerlo nivel de idioma (al menos con C), sólo tiene que asegurarse de que está utilizando sólo las variables definido a través de enum.

Aunque se puede habilitar una de las siguientes advertencias del compilador junto con -Werror:

• -Wswitch
• -Wswitch-default
• -Wswitch-enum

Esto hace que la acumulación fallar si una de las enumeraciones se falta dentro del interruptor.

Answer 6

enumeraciones en C++ ya tienen tipos más fuertes que en C.

Tomemos el siguiente programa simple:

#include <iostream> 

enum E 
{ 
    A, 
    B 
}; 

void f(E e) 
{ 
} 

int main() 
{ 
    f(1); 
} 

Usando el compilador GCC voy a conseguir un este error:

 
enum.cpp: In function ‘int main()’: 
enum.cpp:15: error: invalid conversion from ‘int’ to ‘E’ 
enum.cpp:15: error: initializing argument 1 of ‘void f(E)’ 

Entonces, como puede ver, los miembros de la enumeración ya están marcados.

Si desea una comprobación de tipo aún más sólida y un compilador con capacidad C++ 11, puede usar una verificación de tipo más potente para enumeraciones, consulte http://en.wikipedia.org/wiki/C%2B%2B11#Strongly_typed_enumerations.

Answer 7

Un truco que he utilizado en el pasado:

enum foo {FIRST_FOO, BAR, BLETCH, BLURGA, BLAH, LAST_FOO}; 

y después comprobar para ver si su valor es > FIRST_FOO && < LAST_FOO .

Por supuesto, esto supone que no hay lagunas entre los valores de enumeración.

De lo contrario, no, no hay un buen método para hacer lo que está pidiendo (al menos en C).

---

Desde la última línea C Language Standard:

6.7.2.2 Enumeration specifiers
...
3 The identifiers in an enumerator list are declared as constants that have type int and may appear wherever such are permitted. ¹⁰⁹⁾ An enumerator with = defines its enumeration constant as the value of the constant expression. If the first enumerator has no = , the value of its enumeration constant is 0 . Each subsequent enumerator with no = defines its enumeration constant as the value of the constant expression obtained by adding 1 to the value of the previous enumeration constant. (The use of enumerators with = may produce enumeration constants with values that duplicate other values in the same enumeration.) The enumerators of an enumeration are also known as its members.