Jak sprawdzić, czy zmienna wyliczeniowa jest ważna?

Question

Mam ENUM:

enum myenum{ 
    typeA, 
    typeB, 
    typeC 
} myenum_t; 

Następnie funkcje ma być wywołana z parametrem ENUM:

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

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

Ale, jak myenum_t rośnie wraz z coraz większej wartości, nie wydaje myfunction taki elegancki.

Czy istnieje lepszy sposób sprawdzenia, czy wyliczenie jest poprawne, czy nie?

Answer 1

Wspólna konwencja jest to, aby zrobić coś takiego:

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

Następnie można sprawdzić (t < num_types).

Jeśli następnie dodasz więcej wyliczeń, np.

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

następnie num_types jest automatycznie aktualizowana i twój błąd sprawdzania kodu nie trzeba zmieniać.

Answer 2

Tak.

Pozwól, aby kompilator wykonał swoją pracę, nie używaj od int typu enum i powinieneś być dobry.

Answer 3

Można użyć enum bitowe:

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

wybaczcie, wydaje Czytałem kwestia źle.

Wygląda na to, że chcesz określić, czy masz przekazaną prawidłową wartość, a nie jakąś losową niepoprawną opcję. W tym przypadku najbardziej logicznym rozwiązaniem jest to:

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

Jest to, oczywiście, zakładając, że nie ustawić wartości dla wyliczenia manualnych, co jest dość rzadkie, chyba że przy użyciu bitowe teksty stałe.

Answer 4

nie można też zrobić coś podobnego

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

Niestety nie jest prostym sposobem na to poziom języka (przynajmniej z C), po prostu trzeba się upewnić, że używasz tylko zmienne zdefiniowane przez enum.

Chociaż można włączyć jedną z następujących ostrzeżeń kompilatora wraz z -Werror:

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

To sprawia build powiedzie się, jeśli jeden z teksty stałe pominięcia wewnątrz przełącznika.

Answer 6

Wyliczenia w C++ mają już silniejsze typy niż w C.

Weźmy następujący prosty program:

#include <iostream> 

enum E 
{ 
    A, 
    B 
}; 

void f(E e) 
{ 
} 

int main() 
{ 
    f(1); 
} 

Korzystanie z kompilatora GCC będzie dostaję ten błąd:

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

Tak więc, jak widać, elementy wyliczeniowe są już sprawdzone.

Jeśli chcesz jeszcze silniej sprawdzać typ i mieć kompilator obsługujący C++ 11, możesz użyć jeszcze silniejszego sprawdzania typów dla wyliczeń, zobacz http://en.wikipedia.org/wiki/C%2B%2B11#Strongly_typed_enumerations.

Answer 7

Jeden trick Użyłem w przeszłości:

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

a następnie sprawdzić, czy wartość jest > FIRST_FOO && < LAST_FOO .

Oczywiście zakłada to, że między wartościami wyliczeniowymi nie ma żadnych przerw.

W przeciwnym razie nie, nie ma dobrej metody robienia tego, o co prosisz (przynajmniej w C).

---

Z odświerzyć 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.