Ako používať enum v jazyku C

Program enum v programovacom jazyku C sa používa na definovanie integrálnych konštantných hodnôt, čo je veľmi užitočné pri písaní čistých a čitateľných programov. Programátori zvyčajne používajú výpočet na definovanie pomenovaných integrálnych konštánt vo svojich programoch na zabezpečenie lepšej čitateľnosti a udržiavateľnosti softvéru. Tento článok sa bude podrobne zaoberať enum.

Syntax

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

Predvolená hodnota Enumeration_Constant_Element-1 je 0, hodnota Enumeration_Constant_Element-2 je 1, hodnota Enumeration_Constant_Element-3 je 2 a hodnota Enumeration_Constant_Element-n je (n-1).

Deep Dive into Enum

Teraz, keď poznáme syntax na definovanie typu výčtu, pozrime sa na príklad:

chyba enum
IO_ERROR,
DISK_ERROR,
CHYBA SIETE
;

Na definovanie typu výčtu sa musí vždy použiť kľúčové slovo „enum“. Takže kedykoľvek chcete definovať typ výčtu, musíte predtým použiť kľúčové slovo „enum“ . Za kľúčovým slovom „enum“ musíte na definovanie súboru použiť platný identifikátor .

Vo vyššie uvedenom príklade kompilátor priradí IO_ERROR integrálnej hodnote: 0, DISK_ERROR integrálnej hodnote: 1 a NETWORK_ERROR integrálnej hodnote: 2. V predvolenom nastavení je prvému prvku výčtu vždy priradená hodnota 0, ďalšiemu prvku výčtu je priradená hodnota 1 atď.

Toto predvolené správanie je možné v prípade potreby zmeniť explicitným priradením konštantnej integrálnej hodnoty, a to nasledovne:

chyba enum
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8 ,
PRINT_ERROR
;

V takom prípade programátor explicitne priradí IO_ERROR k hodnote 2, kompilátor DISK_ERROR priradí k hodnote 3, programátor explicitne priradí NETWORK_ERROR k hodnote 8 a ďalšiemu PRINT_ERROR. integrálna hodnota predchádzajúceho prvku enum NETWORK_ERROR (t.j.e., 9) kompilátorom.

Takže teraz chápete, ako definovať používateľom definovaný typ výčtu v jazyku C. Je možné deklarovať premennú typu enum (ako môžeme deklarovať premennú celočíselného typu)? Áno, je! Premennú enum môžete deklarovať takto:

chyba enum Hw_Error;

„Enum“ je tu opäť kľúčové slovo, „Error“ je typ enum a „Hw_Error“ je premenná enum.

Teraz sa pozrieme na nasledujúce príklady, aby sme pochopili rôzne spôsoby použitia enumu:

Príklad 1: Predvolené použitie definície výčtu
Príklad 2: Použitie vlastnej definície výčtu
Príklad 3: Definícia výčtu pomocou konštantného výrazu
Príklad 4: rozsah enum

Príklad 1: Predvolený výčet Definícia Použitie

V tomto príklade sa naučíte, ako definovať typ výčtu s predvolenými konštantnými hodnotami. Kompilátor sa postará o priradenie predvolených hodnôt k prvkom enum. Ďalej uvidíte ukážkový program a zodpovedajúci výstup.

#include
/ * Definujte typ výčtu * /
chyba enum
IO_ERROR,
DISK_ERROR,
CHYBA SIETE
;
int main ()

chyba enum Hw_Error; / * Vytváranie premennej enum * /
printf ("Nastavenie Hw_Error na IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
návrat 0;

Príklad 2: Použitie definície vlastného výčtu

V tomto príklade sa naučíte, ako definovať typ výčtu s vlastnou konštantnou hodnotou. Tento príklad vám tiež pomôže pochopiť, ako je možné inicializáciu vlastných konštánt vykonať v ľubovoľnom náhodnom poradí. V tomto príklade sme explicitne definovali konštantnú hodnotu pre 1^sv a 3^rd prvky výčtu (t.j.e., IO_ERROR a NETWORK_ERROR), ale preskočili sme explicitnú inicializáciu pre 2^nd a 4^th prvkov. Teraz je zodpovednosťou kompilátora priradiť predvolené hodnoty 2^nd a 4^th prvky výčtu (t.j.e., DISK_ERROR a PRINT_ERROR). DISK_ERROR bude priradený k hodnote 3 a PRINT_ERROR bude priradený k hodnote 9. Ďalej uvidíte ukážkový program a výstup.

#include
/ * Definujte typ enum - vlastná inicializácia * /
chyba enum
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int main ()

/ * Deklarovať premennú enum * /
chyba enum Hw_Error;
printf ("Nastavenie Hw_Error na IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
návrat 0;

Príklad 3: Definícia výčtu pomocou konštantného výrazu

V tomto príklade sa naučíte, ako používať konštantný výraz na definovanie konštantnej hodnoty pre prvky enum.

#include
/ * Definujte typ enum - vlastnú inicializáciu pomocou konštantného výrazu
konštantný výraz sa tu používa v prípade:
a. IO_ERROR a
b. CHYBA SIETE
Toto je neobvyklý spôsob definovania prvkov enum; však toto
program demonštruje, že tento spôsob inicializácie prvkov enum je možný vc.
* /
chyba enum
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Deklarovať premennú enum * /
chyba výčtu Hw_Error;
printf ("Nastavenie Hw_Error na IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
návrat 0;

Príklad 4: Rozsah enum

V tomto príklade sa dozviete, ako funguje pravidlo určovania rozsahu pre enum. Na definovanie konštanty namiesto výčtu bolo možné použiť makro (#define), ale pravidlo pre rozsah nefunguje pre makro.

#include
int main ()

/ * Definujte typ výčtu * /
enum Error_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Definujte typ enum vo vnútornom rozsahu * /
enum Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Deklarovať premennú enum * /
enum Error_1 Hw_Error;
printf ("Nastavenie Hw_Error na IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);
printf ("\ nNastavenie Hw_Error na PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hodnota Hw_Error =% d \ n", Hw_Error);

návrat 0;

Porovnanie medzi enumom a makrom

Enum

Makro

Pravidlo rozsahu je použiteľné pre enum.

Pravidlo rozsahu nie je použiteľné pre makro.

Priradenie predvolenej hodnoty Enum sa deje automaticky.

Enum je veľmi užitočný pri definovaní veľkého počtu konštánt. Kompilátor prevezme inicializáciu predvolenej konštantnej hodnoty.

Programátor musí vždy výslovne uviesť hodnoty makro konštanty.

Môže to byť zdĺhavý proces pre veľké množstvo konštánt, pretože programátor musí pri definovaní makra vždy manuálne definovať každú konštantnú hodnotu.

Záver

Program enum v jazyku C by sa mohol považovať za voliteľnú metódu pre samostatné programy alebo malé projekty, pretože programátori môžu vždy používať makro namiesto enum. Skúsení programátori však majú tendenciu používať enum nad makrom pre veľké projekty vývoja softvéru. To pomáha pri písaní čistých a čitateľných programov.