Come verificare se una variabile enum è valida?

Question

Ho un enum:

enum myenum{ 
    typeA, 
    typeB, 
    typeC 
} myenum_t; 

Poi, funzioni deve essere chiamato con un parametro enum:

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

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

Ma, come myenum_t cresce con sempre più valori, myfunction non sembra così elegante.

C'è un modo migliore per verificare se un enum è valido o no?

Answer 1

Una convenzione comune per questo è di fare qualcosa di simile:

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

Quindi è possibile verificare la presenza di (t < num_types).

Se successivamente aggiungi più enumerazioni, ad es.

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

poi num_types si aggiorna automaticamente e il vostro controllo degli errori di codice non ha bisogno di cambiare.

Answer 2

Sì.

Lascia che il compilatore faccia il suo lavoro, non trasmettere int a un tipo enum e si dovrebbe essere buono.

Answer 3

si potrebbe usare un enum 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; 
} 

Mi scusi, mi sembra di aver letto la domanda sbagliata.

Sembra che ciò che si vuole fare è determinare se si è passato un valore corretto, non un'opzione casuale non valida. In tal caso, l'opzione più logica è questa:

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

Questo è, naturalmente, a patto che non si imposta i valori manuali per la vostra enum, che, è abbastanza raro a meno di utilizzare enumerazioni bit per bit.

Answer 4

Non può anche fare qualcosa di simile

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

Purtroppo non c'è un modo semplice per farlo livello linguistico (almeno con C), devi solo fare in modo che si sta utilizzando solo le variabili definito tramite enum.

Anche se è possibile attivare uno dei seguenti avvisi del compilatore insieme -Werror:

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

Questo rende accumulo fallire se una delle enumerazioni è mancato interruttore interno.

Answer 6

enumerazioni in C++ già avere tipi più forti in C.

Prendere il seguente programma semplice:

#include <iostream> 

enum E 
{ 
    A, 
    B 
}; 

void f(E e) 
{ 
} 

int main() 
{ 
    f(1); 
} 

Utilizzando il compilatore GCC otterrò un questo errore:

 
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)’ 

Quindi, come puoi vedere, i membri dell'enumerazione sono già stati controllati.

Se si vuole ancora più forte controllo dei tipi, e hanno un C++ 11 compilatore in grado, è possibile utilizzare anche più forte tipo di controllo per le enumerazioni, vedi http://en.wikipedia.org/wiki/C%2B%2B11#Strongly_typed_enumerations.

Answer 7

Un trucco che ho usato in passato:

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

e quindi controllare per vedere se il valore è > FIRST_FOO && < LAST_FOO .

Ovviamente, ciò presuppone che non vi siano intervalli tra i valori di enumerazione.

Altrimenti no, non esiste un metodo valido per fare ciò che stai chiedendo (almeno in C).

---

Dalle ultime linea 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.