Jak używać enum w języku c

Jak używać enum w języku c
Program enum w języku programowania C służy do definiowania integralnych stałych wartości, co jest bardzo pomocne w pisaniu czystych i czytelnych programów. Programiści zwykle używają wyliczenia do zdefiniowania nazwanych stałych integralnych w swoich programach, aby zapewnić lepszą czytelność i utrzymanie oprogramowania. W tym artykule szczegółowo omówiono enum.

Składnia

enum
Enumeration_constant_element-1,
Enumeration_constant_element-2,
Enumeration_constant_element-3,
… ,
Enumeration_constant_element-n,
;

Domyślna wartość enumeration_constant_element-1 wynosi 0, wartość enumeration_constant_element-2 wynosi 1, wartość enumeration_constant_element-3 wynosi 2, a wartość enumeration_constant_element-n wynosi (n-1).

Głębokie zanurzenie się w enum

Teraz, ponieważ znamy składnię, aby zdefiniować typ wyliczenia, spójrzmy na przykład:

Błąd wyliczania
Io_error,
Dysk_error,
BŁĄD SIECI
;

Słowo kluczowe „enum” musi być zawsze używane do zdefiniowania typu wyliczenia. Tak więc, gdy chcesz zdefiniować typ wyliczenia, musisz wcześniej użyć słowa kluczowego „enum” . Po słowie kluczowym „enum” musisz użyć prawidłowego identyfikatora do zdefiniowania .

W powyższym przykładzie kompilator przypisuje IO_ERROR do wartości całkowej: 0, Disk_error do wartości całkowej: 1 i Network_error do wartości całkowej: 2. Domyślnie pierwsza element wyliczania jest zawsze przypisywany wartość 0, następne element enum jest przypisany wartość 1 i tak dalej.

To domyślne zachowanie można zmienić, jeśli to konieczne, jawnie przypisując stałą wartość całkową, w następujący sposób:

Błąd wyliczania
Io_error = 2,
Dysk_error,
Network_error = 8 ,
Print_error
;

W takim przypadku IO_ERROR jest wyraźnie przypisany do wartości 2 przez programista, dysk_error jest przypisywany do wartości 3 przez kompilatora, Network_error jest wyraźnie przypisany do wartości 8 przez programista, a print_error jest przypisany do następnego integralna wartość poprzedniego elementu enum Network_error (i.mi., 9) przez kompilator.

Więc teraz rozumiesz, jak zdefiniować typ wyliczenia zdefiniowanego przez użytkownika w C. Czy można zadeklarować zmienną typu enum (ponieważ możemy zadeklarować zmienną typu liczb całkowitych)? Tak to jest! Możesz zadeklarować zmienną enum w następujący sposób:

enum Error Hw_ERROR;

Ponownie „enum” jest tutaj słowem kluczowym, „błąd” jest typem enum, a „hw_error” jest zmienną enum.

Przyjrzymy się teraz następującym przykładom, aby zrozumieć różne zastosowania enum:

  • Przykład 1: Domyślne użycie definicji enum
  • Przykład 2: Użycie definicji niestandardowej enum
  • Przykład 3: Definicja enum za pomocą stałego wyrażenia
  • Przykład 4: Zakres wyliczania

Przykład 1: Domyślne użycie definicji enum

W tym przykładzie dowiesz się, jak zdefiniować typ wyliczenia z domyślnymi wartościami stałymi. Kompilator zajmie się przypisaniem wartości domyślnych do elementów enum. Poniżej zobaczysz przykładowy program i odpowiednie wyjście.

#włączać
/ * Zdefiniuj typ enum */
Błąd wyliczania
Io_error,
Dysk_error,
BŁĄD SIECI
;
int main ()

enum Error Hw_ERROR; /* Tworzenie zmiennej enum*/
printf („Ustawienie hw_error na io_error \ n”);
Hw_error = io_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error na dysk_error \ n");
Hw_error = disk_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting HW_ERROR do sieci_error \ n");
Hw_error = network_error;
printf („Wartość hw_error = %d \ n”, hw_error);
powrót 0;

Przykład 2: Użycie definicji niestandardowej enum

W tym przykładzie dowiesz się, jak zdefiniować typ wyliczenia z niestandardową wartością stałą. Ponadto ten przykład pomoże ci zrozumieć, w jaki sposób inicjalizacja stałych niestandardowych można wykonać w dowolnej losowej kolejności. W tym przykładzie wyraźnie zdefiniowaliśmy stałą wartość dla 1St i 3r & D Enum Elements (i.mi., Odpowiednio io_error i network_error), ale pominęliśmy wyraźną inicjalizację dla 2Nd i 4th elementy. Obecnie obowiązkiem kompilatora przypisanie wartości domyślnych do 2Nd i 4th Enum Elements (i.mi., Odpowiednio dysk_error i print_error). Disk_error zostanie przypisany do wartości 3, a print_error zostanie przypisany do wartości 9. Poniżej zobaczysz przykładowy program i wyjście.

#włączać
/* Zdefiniuj typ enum - niestandardowa inicjalizacja*/
Błąd wyliczania
Io_error = 2,
Dysk_error,
Network_error = 8,
Print_error
;
int main ()

/* Deklaruj zmienną enum*/
enum Error Hw_ERROR;
printf („Ustawienie hw_error na io_error \ n”);
Hw_error = io_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error na dysk_error \ n");
Hw_error = disk_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting HW_ERROR do sieci_error \ n");
Hw_error = network_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error do print_error \ n");
Hw_error = print_error;
printf („Wartość hw_error = %d \ n”, hw_error);
powrót 0;

Przykład 3: Definicja enum za pomocą stałego wyrażenia

W tym przykładzie dowiesz się, jak używać stałego wyrażenia, aby zdefiniować stałą wartość dla elementów enum.

#włączać
/* Zdefiniuj typ enum - niestandardowa inicjalizacja za pomocą stałego wyrażenia
W przypadku: w przypadku:
A. Io_error i
B. BŁĄD SIECI
Jest to niezwykły sposób definiowania elementów enum; Jednak to
Program pokazuje, że ten sposób inicjalizacji elementów enum jest możliwy w C.
*/
Błąd wyliczania
Io_error = 1 + 2 * 3 + 4,
Dysk_error,
Network_error = 2 == 2,
Print_error
;
int main ()

/* Deklaruj zmienną enum*/
enum Error Hw_ERROR;
printf („Ustawienie hw_error na io_error \ n”);
Hw_error = io_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error na dysk_error \ n");
Hw_error = disk_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting HW_ERROR do sieci_error \ n");
Hw_error = network_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error do print_error \ n");
Hw_error = print_error;
printf („Wartość hw_error = %d \ n”, hw_error);
powrót 0;

Przykład 4: Zakres wyliczania

W tym przykładzie dowiesz się, jak działa reguła zasięgu dla enum. Makro (#Define) mogło być użyte do zdefiniowania stałej zamiast wyliczania, ale reguła zasięgu nie działa dla makro.

#włączać
int main ()

/ * Zdefiniuj typ enum */
enum error_1
IO_ERROR = 10,
Dysk_error,
Network_error = 3,
Print_error
;

/* Zdefiniuj typ enum w zakresie wewnętrznego*/
enum error_1
IO_ERROR = 20,
Dysk_error,
Network_error = 35,
Print_error
;
/* Deklaruj zmienną enum*/
enum error_1 hw_error;
printf („Ustawienie hw_error na io_error \ n”);
Hw_error = io_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error na dysk_error \ n");
Hw_error = disk_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting HW_ERROR do sieci_error \ n");
Hw_error = network_error;
printf („Wartość hw_error = %d \ n”, hw_error);
printf ("\ nsetting hw_error do print_error \ n");
Hw_error = print_error;
printf („Wartość hw_error = %d \ n”, hw_error);

powrót 0;

Porównanie enum i makro

Enum Makro
Zasada scoping ma zastosowanie do enum. Zasada scoping nie ma zastosowania do makro.
Domyślne przypisanie wartości wyliczania odbywa się automatycznie.

Enum jest bardzo pomocny w definiowaniu dużej liczby stałych. Kompilator przyjmuje domyślną inicjalizację stałej wartości.

Stałe wartości makro muszą być zawsze jawnie wymieniane przez programistę.

Może to być żmudny proces dla dużej liczby stałych, ponieważ programista musi zawsze ręcznie zdefiniować każdą stałą wartość podczas definiowania makra.

Wniosek

Program enum w C można uznać za opcjonalną metodę dla samodzielnych programów lub projektów o małych rozmiarach, ponieważ programiści zawsze mogą używać makro zamiast enum. Jednak doświadczeni programiści zwykle używają enum ponad makro do dużych projektów tworzenia oprogramowania. Pomaga to w pisaniu czystych i czytelnych programów.