Kaip naudoti „enum“ C kalboje

„C“ programavimo kalbos „enum“ programa naudojama integralinėms pastovioms reikšmėms apibrėžti, o tai labai padeda rašant švarias ir skaitomas programas. Programuotojai, norėdami užtikrinti geresnį programinės įrangos įskaitomumą ir prieinamumą, paprastai naudoja įvardijimą, norėdami apibrėžti įvardytas integralines konstantas savo programose. Šiame straipsnyje bus išsamiai aptariamas „enum“.

Sintaksė

enum
Surašymas_Nuolatinis_elementas-1,
Surašymas_Nuolatinis_elementas-2,
Surašymas_Nuolatinis_elementas-3,
… ,
Surašymas_Nuolatinis_elementas-n,
;

Numatytoji „Enumeration_Constant_Element-1“ vertė yra 0, „Enumeration_Constant_Element-2“ vertė yra 1, „Enumeration_Constant_Element-3“ vertė yra 2, o „Enumeration_Constant_Element-n“ vertė yra (n-1).

Giliai pasinerkite į „Enum“

Kadangi žinome sintaksę, kad apibrėžtume surašymo tipą, pažiūrėkime į pavyzdį:

enum Error
IO_ERROR,
DISK_ERROR,
TINKLO KLAIDA
;

Aprašymo tipui apibrėžti visada turi būti naudojamas raktinis žodis „enum“. Taigi, kai norite apibrėžti surašymo tipą, prieš tai turite naudoti raktinį žodį „enum“ . Po „enum“ raktinio žodžio, norėdami apibrėžti, turite naudoti galiojantį identifikatorių .

Ankstesniame pavyzdyje kompiliatorius priskirs IO_ERROR integralo vertei: 0, DISK_ERROR integralo vertei: 1 ir NETWORK_ERROR integralo vertei: 2. Pagal numatytuosius nustatymus pirmajam „enum“ elementui visada priskiriama reikšmė 0, kitam „enum“ elementui - 1 vertė ir t. T.

Šį numatytąjį elgesį prireikus galima pakeisti, priskiriant pastoviąją integralo vertę aiškiai taip:

enum Error
IO_ERROR = 2,
DISK_ERROR,
TINKLO_KLAIDA = 8 ,
PRINT_ERROR
;

Tokiu atveju programuotojas IO_ERROR aiškiai priskiria 2 vertei, kompiliatorius DISK_ERROR priskiria 3 vertei, NETWORK_ERROR programuotojui aiškiai priskiriama 8 vertei, o PRINT_ERROR priskiriama kitam ankstesnio enum elemento NETWORK_ERROR integralinė vertė (t.e., 9) sudarytojas.

Taigi, jūs dabar suprantate, kaip apibrėžti vartotojo apibrėžtą surašymo tipą C. Ar galima deklaruoti kintamąjį, kurio tipas yra enum (nes galime deklaruoti kintamąjį, kurio tipas yra sveikas skaičius)? Taip tai yra! „Enum“ kintamąjį galite paskelbti taip:

enum Klaida Hw_Error;

Vėlgi, „enum“ yra raktinis žodis, „Error“ yra enum tipas, o „Hw_Error“ yra enum kintamasis.

Dabar apžvelgsime šiuos pavyzdžius, kad suprastume įvairius „enum“ įpročius:

1 pavyzdys: numatytasis „enum“ apibrėžimo naudojimas
2 pavyzdys: „Custom Enum“ apibrėžimo naudojimas
3 pavyzdys: „Enum“ apibrėžimas naudojant pastovią išraišką
4 pavyzdys: „enum“ taikymo sritis

1 pavyzdys: Numatytasis sąrašas Apibrėžimas Naudojimas

Šiame pavyzdyje sužinosite, kaip apibrėžti surašymo tipą su numatytosiomis pastoviosiomis vertėmis. Kompiliatorius pasirūpins numatytųjų reikšmių priskyrimu „enum“ elementams. Žemiau pamatysite programos pavyzdį ir atitinkamą išvestį.

# įtraukti
/ * Apibrėžkite enum tipą * /
enum Error
IO_ERROR,
DISK_ERROR,
TINKLO KLAIDA
;
int main ()

enum Klaida Hw_Error; / * Kuriamas „enum“ kintamasis * /
printf ("Hw_Error nustatymas į IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
grąžinti 0;

2 pavyzdys: „Custom enum“ apibrėžimo naudojimas

Šiame pavyzdyje sužinosite, kaip apibrėžti surašymo tipą su pasirinkta pastovia verte. Be to, šis pavyzdys padės suprasti, kaip inicializuoti pasirinktines konstantas galima bet kokia atsitiktine tvarka. Šiame pavyzdyje mes aiškiai apibrėžėme 1 pastoviąją vertę^šv ir 3^rd enum elementai (t.e., IO_ERROR ir NETWORK_ERROR), bet mes praleidome aiškų 2^nd ir 4^tūkst elementai. Dabar kompiliatorius yra atsakingas už numatytųjų verčių priskyrimą 2^nd ir 4^tūkst enum elementai (t.e., Atitinkamai „DISK_ERROR“ ir „PRINT_ERROR“). DISK_ERROR bus priskirta 3 vertei, o PRINT_ERROR bus priskirta 9 vertei. Žemiau pamatysite programos pavyzdį ir išvestį.

# įtraukti
/ * Apibrėžkite sąrašo tipą - Pasirinktinis inicijavimas * /
enum Error
IO_ERROR = 2,
DISK_ERROR,
TINKLO_KLAIDA = 8,
PRINT_ERROR
;
int main ()

/ * Paskelbkite „enum“ kintamąjį * /
enum Klaida Hw_Error;
printf ("Hw_Error nustatymas į IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
grąžinti 0;

3 pavyzdys: „Enum“ apibrėžimas naudojant nuolatinę išraišką

Šiame pavyzdyje sužinosite, kaip naudoti pastoviąją išraišką apibrėžiant „enum“ elementų pastoviąją vertę.

# įtraukti
/ * Apibrėžkite „enum“ tipą - pasirinktinis inicialavimas naudojant pastovią išraišką
pastovi išraiška čia naudojama:
a. IO_ERROR ir
b. TINKLO KLAIDA
Tai neįprastas būdas apibrėžti „enum“ elementus; tačiau tai
programa parodo, kad šis enum elementų inicializavimo būdas yra įmanomas c.
* /
enum Error
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
TINKLO_KLAIDA = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Paskelbkite „enum“ kintamąjį * /
enum Klaida Hw_Error;
printf ("Hw_Error nustatymas į IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
grąžinti 0;

4 pavyzdys: „Enum“ taikymo sritis

Šiame pavyzdyje sužinosite, kaip taikymo srities taisyklė veikia „enum“. MACRO (#define) galėjo būti naudojamas norint apibrėžti konstantą vietoj enum, tačiau taikymo srities taisyklė neveikia MACRO.

# įtraukti
int main ()

/ * Apibrėžkite enum tipą * /
enume Error_1
IO_ERROR = 10,
DISK_ERROR,
TINKLAS_KLAIDA = 3,
PRINT_ERROR
;

/ * Apibrėžkite enum tipą vidinėje sferoje * /
enume Error_1
IO_ERROR = 20,
DISK_ERROR,
TINKLAS_KLAIDA = 35,
PRINT_ERROR
;
/ * Paskelbkite „enum“ kintamąjį * /
enum Error_1 Hw_Error;
printf ("Hw_Error nustatymas į IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);
printf ("\ nHw_Error nustatymas į PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Hw_Error =% d \ n" reikšmė, Hw_Error);

grąžinti 0;

„Enum“ ir „makro“ palyginimas

Enum

Makrokomanda

Taikymo srities taisyklė taikoma „enum“.

Apimties taisyklė netaikoma makrokomandai.

Numatytasis „Enum“ vertės priskyrimas įvyksta automatiškai.

Enumas yra labai naudingas apibrėžiant daugybę konstantų. Kompiliatorius inicijuoja numatytąją pastoviąją vertę.

Programuotojas visada turi aiškiai nurodyti makrokomandos reikšmes.

Tai gali būti varginantis procesas daugybei konstantų, nes programuotojas visada turi rankiniu būdu apibrėžti kiekvieną pastoviąją vertę, apibrėždamas makrokomandą.

Išvada

„C“ sąrašo programa gali būti laikoma pasirinktiniu atskirų programų ar mažų projektų metodu, nes programuotojai visada gali naudoti makrokomandas, o ne „enum“. Tačiau patyrę programuotojai yra linkę naudoti „enum“, o ne „makro“, didelio masto programinės įrangos kūrimo projektams. Tai padeda rašyti švarias ir įskaitomas programas.