Sådan bruges enum i C-sprog

Enum-programmet på programmeringssprog C bruges til at definere integrerede konstante værdier, hvilket er meget nyttigt ved skrivning af rene og læsbare programmer. Programmører bruger normalt optælling til at definere navngivne integrerede konstanter i deres programmer for at give bedre læsbarhed og vedligeholdelse af softwaren. Denne artikel vil diskutere enum i detaljer.

Syntaks

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

Standardværdien af Enumeration_Constant_Element-1 er 0, værdien af Enumeration_Constant_Element-2 er 1, værdien af Enumeration_Constant_Element-3 er 2, og værdien af Enumeration_Constant_Element-n er (n-1).

Dyb dykk ned i Enum

Nu, da vi kender syntaksen til at definere optællingstypen, lad os se på et eksempel:

enum-fejl
IO_ERROR,
DISK_ERROR,
NETVÆRKSFEJL
;

Nøgleordet "enum" skal altid bruges til at definere optællingstypen. Så når du vil definere en optællingstype, skal du bruge nøgleordet "enum" før . Efter nøgleordet "enum" skal du bruge en gyldig identifikator til at definere .

I ovenstående eksempel tildeler compileren IO_ERROR til integralværdien: 0, DISK_ERROR til integralværdien: 1 og NETWORK_ERROR til integralværdien: 2. Som standard tildeles det første enum-element altid værdien 0, det næste enum-element tildeles værdien 1 osv.

Denne standardadfærd kan om nødvendigt ændres ved at tildele den konstante integralværdi eksplicit som følger:

enum-fejl
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8 ,
PRINT_ERROR
;

I dette tilfælde tildeles IO_ERROR eksplicit til en værdi på 2 af programmøren, DISK_ERROR tildeles en værdi på 3 af compileren, NETWORK_ERROR tildeles eksplicit værdien 8 af programmøren, og PRINT_ERROR tildeles den næste integreret værdi af det forrige enum-element NETWORK_ERROR (i.e., 9) af kompilatoren.

Så du forstår nu, hvordan du definerer en brugerdefineret optællingstype i C. Er det muligt at erklære en variabel af enum-typen (som vi kan erklære en variabel af heltalstype)? Ja det er! Du kan erklære enum-variablen som følger:

enum Fejl Hw_Error;

Igen er "enum" nøgleordet her, "Error" er enumtypen, og "Hw_Error" er en enum-variabel.

Vi vil nu se på følgende eksempler for at forstå de forskellige anvendelser af enum:

Eksempel 1: Standard brug af enumdefinition
Eksempel 2: Brug af brugerdefineret enumdefinition
Eksempel 3: definition af enum ved anvendelse af konstant udtryk
Eksempel 4: Enum scope

Eksempel 1: Standard enum Definition Usage

I dette eksempel lærer du, hvordan du definerer optællingstypen med standardkonstantværdier. Compileren sørger for at tildele standardværdierne til enum-elementerne. Nedenfor ser du eksempelprogrammet og den tilsvarende output.

#omfatte
/ * Definer enumtypen * /
enum-fejl
IO_ERROR,
DISK_ERROR,
NETVÆRKSFEJL
;
int main ()

enum Fejl Hw_Error; / * Oprettelse af enum-variabel * /
printf ("Indstilling af Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nSætning af Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
returnere 0;

Eksempel 2: Definition af brugerdefineret enum

I dette eksempel lærer du, hvordan du definerer optællingstypen med en brugerdefineret konstantværdi. Dette eksempel hjælper dig også med at forstå, hvordan initialiseringen af brugerdefinerede konstanter kan udføres i en vilkårlig rækkefølge. I dette eksempel har vi eksplicit defineret den konstante værdi for 1^St og 3^rd enum-elementer (i.e., IO_ERROR henholdsvis NETWORK_ERROR), men vi har sprunget over den eksplicitte initialisering til 2^nd og 4^th elementer. Det er nu kompilatorens ansvar at tildele standardværdierne til 2^nd og 4^th enum-elementer (i.e., DISK_ERROR henholdsvis PRINT_ERROR). DISK_ERROR tildeles en værdi på 3 og PRINT_ERROR tildeles en værdi på 9. Nedenfor ser du eksempelprogrammet og output.

#omfatte
/ * Definer enumtypen - Tilpasset initialisering * /
enum-fejl
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int main ()

/ * Erklær enum-variabel * /
enum Fejl Hw_Error;
printf ("Indstilling af Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nSæt Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
returnere 0;

Eksempel 3: Enumdefinition ved hjælp af konstant udtryk

I dette eksempel lærer du, hvordan du bruger det konstante udtryk til at definere den konstante værdi for enum-elementer.

#omfatte
/ * Definer enumtypen - brugerdefineret initialisering ved hjælp af konstant udtryk
konstant udtryk bruges her i tilfælde af:
-en. IO_ERROR og
b. NETVÆRKSFEJL
Dette er en usædvanlig måde at definere enum-elementerne på; dog dette
programmet viser, at denne måde at initialisere enum-elementer er mulig i c.
* /
enum-fejl
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Erklær enum-variabel * /
enum Fejl Hw_Error;
printf ("Indstilling af Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nSæt Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
returnere 0;

Eksempel 4: Enum Anvendelsesområde

I dette eksempel lærer du, hvordan scoping-reglen fungerer for enum. En MACRO (#define) kunne have været brugt til at definere en konstant i stedet for enum, men scoping-reglen fungerer ikke for MACRO.

#omfatte
int main ()

/ * Definer enumtypen * /
enum Error_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Definer enumtypen i det indre omfang * /
enum Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Erklær enum-variabel * /
enum Error_1 Hw_Error;
printf ("Indstilling af Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nIndstilling af Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);
printf ("\ nSæt Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Værdi af Hw_Error =% d \ n", Hw_Error);

returnere 0;

Sammenligning mellem enum og makro

Enum

Makro

Omfangsregel gælder for enum.

Omfangsregel gælder ikke for makro.

Standard Enum-værditildeling sker automatisk.

Enum er meget nyttigt med at definere et stort antal konstanter. Compileren tager standardkonstantværdiinitialiseringen.

Makrokonstantværdierne skal altid nævnes eksplicit af programmøren.

Dette kan være en kedelig proces for et stort antal konstanter, da programmøren altid skal manuelt definere hver konstante værdi, mens makroen defineres.

Konklusion

Enum-programmet i C kan betragtes som en valgfri metode til enkeltstående programmer eller små projekter, da programmører altid kan bruge makro i stedet for en enum. Imidlertid har erfarne programmører tendens til at bruge enum over macro til store softwareudviklingsprojekter. Dette hjælper med at skrive rene og læsbare programmer.