Hvordan bruke enum i C Language

Enum-programmet i programmeringsspråket C brukes til å definere integrerte konstante verdier, noe som er veldig nyttig for å skrive rene og lesbare programmer. Programmører bruker normalt oppregning for å definere navngitte integrerte konstanter i programmene sine for å gi bedre lesbarhet og vedlikehold av programvaren. Denne artikkelen vil diskutere enum i detalj.

Syntaks

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

Standardverdien for Enumeration_Constant_Element-1 er 0, verdien av Enumeration_Constant_Element-2 er 1, verdien av Enumeration_Constant_Element-3 er 2, og verdien av Enumeration_Constant_Element-n er (n-1).

Dykk inn i Enum

Nå, siden vi vet syntaksen for å definere nummereringstypen, la oss se på et eksempel:

enum Error
IO_ERROR,
DISK_ERROR,
NETTVERKSFEIL
;

Nøkkelordet "enum" må alltid brukes til å definere nummereringstypen. Så når du vil definere en oppregningstype, må du bruke nøkkelordet "enum" før . Etter "enum" nøkkelordet, må du bruke en gyldig identifikator for å definere .

I eksemplet ovenfor vil kompilatoren tildele IO_ERROR til integralverdien: 0, DISK_ERROR til integralverdien: 1 og NETWORK_ERROR til integralverdien: 2. Som standard tildeles det første enum-elementet alltid verdien 0, det neste enum-elementet tildeles verdien 1, og så videre.

Denne standardadferden kan endres om nødvendig ved å tilordne den konstante integralverdien eksplisitt, som følger:

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

I dette tilfellet tildeles IO_ERROR eksplisitt til en verdi av 2 av programmereren, DISK_ERROR er tilordnet en verdi på 3 av kompilatoren, NETWORK_ERROR er eksplisitt tildelt verdien 8 av programmereren, og PRINT_ERROR er tilordnet til neste integrert verdi av forrige enum-element NETWORK_ERROR (i.e., 9) av kompilatoren.

Så du forstår nå hvordan du definerer en brukerdefinert oppregningstype i C. Er det mulig å erklære en variabel av enumtype (som vi kan erklære en variabel av heltallstype)? Ja, det er det! Du kan erklære enum-variabelen som følger:

enum Feil Hw_Error;

Igjen er "enum" nøkkelordet her, "Error" er enum-typen, og "Hw_Error" er en enum-variabel.

Vi vil nå se på følgende eksempler for å forstå de forskjellige bruksområdene i enum:

Eksempel 1: Standard bruk av definisjon av enum
Eksempel 2: Bruk av enum definisjon
Eksempel 3: definisjon av enum ved bruk av konstant uttrykk
Eksempel 4: Enum scope

Eksempel 1: Standard enum Definisjon Bruk

I dette eksemplet lærer du hvordan du definerer oppregningstypen med standard konstante verdier. Kompilatoren tar seg av å tilordne standardverdiene til enum-elementene. Nedenfor ser du eksempelprogrammet og tilhørende utdata.

#inkludere
/ * Definer enumtypen * /
enum Error
IO_ERROR,
DISK_ERROR,
NETTVERKSFEIL
;
int main ()

enum Feil Hw_Error; / * Opprette enumvariabel * /
printf ("Setter Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
retur 0;

Eksempel 2: Definisjon av egendefinert bruk

I dette eksemplet lærer du hvordan du definerer oppregningstypen med en tilpasset konstantverdi. I tillegg vil dette eksemplet hjelpe deg med å forstå hvordan initialisering av egendefinerte konstanter kan gjøres i en vilkårlig rekkefølge. I dette eksemplet har vi eksplisitt definert den konstante verdien for 1^St og 3^rd enum elementer (i.e., IO_ERROR henholdsvis NETWORK_ERROR), men vi har hoppet over den eksplisitte initialiseringen for de 2^nd og 4^th elementer. Det er nå kompilatorens ansvar å tilordne standardverdiene til 2^nd og 4^th enum elementer (i.e., DISK_ERROR og PRINT_ERROR, henholdsvis). DISK_ERROR tildeles verdien 3 og PRINT_ERROR tildeles verdien 9. Nedenfor ser du eksempelprogrammet og utdataene.

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

/ * Erklare enum-variabel * /
enum Feil Hw_Error;
printf ("Setter Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
retur 0;

Eksempel 3: Enumdefinisjon ved bruk av konstant uttrykk

I dette eksemplet lærer du hvordan du bruker konstantuttrykket til å definere konstantverdien for enum-elementer.

#inkludere
/ * Definer enumtypen - tilpasset initialisering ved hjelp av konstant uttrykk
konstant uttrykk brukes her i tilfelle:
en. IO_ERROR og
b. NETTVERKSFEIL
Dette er en uvanlig måte å definere enum-elementene på; imidlertid dette
programmet viser at denne måten å initialisere enum-elementer er mulig i c.
* /
enum Error
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETTVERK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Erklare enum-variabel * /
enum Feil Hw_Error;
printf ("Setter Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
retur 0;

Eksempel 4: enum Omfang

I dette eksemplet vil du lære hvordan omfangsregelen fungerer for enum. En MACRO (#define) kunne ha blitt brukt til å definere en konstant i stedet for enum, men avgrensningsregelen fungerer ikke for MACRO.

#inkludere
int main ()

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

/ * Definer enumtypen i det indre omfanget * /
enum Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Erklær enum-variabel * /
enum Error_1 Hw_Error;
printf ("Setter Hw_Error til IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);
printf ("\ nSette Hw_Error til PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Verdi av Hw_Error =% d \ n", Hw_Error);

retur 0;

Sammenligning mellom enum og makro

Enum

Makro

Omfangsregel gjelder for enum.

Omfangsregel gjelder ikke for makro.

Standard Enum-verditildeling skjer automatisk.

Enum er veldig nyttig i å definere et stort antall konstanter. Kompilatoren tar standard initialisering av konstant verdi.

Makrokonstantverdiene må alltid nevnes eksplisitt av programmereren.

Dette kan være en kjedelig prosess for et stort antall konstanter siden programmereren alltid må definere hver konstante verdi manuelt mens man definerer makroen.

Konklusjon

Enum-programmet i C kan betraktes som en valgfri metode for frittstående programmer eller små prosjekter, siden programmerere alltid kan bruke makro i stedet for en enum. Imidlertid har erfarne programmerere en tendens til å bruke enum over macro for store programvareutviklingsprosjekter. Dette hjelper med å skrive rene og lesbare programmer.