Hvordan bruke enum på C -språk

How Use Enum C Language



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

Syntaks

enum <Navn på Enum Type> {
Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-n,
};

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







Dyp dykk ned i Enum

Siden vi kjenner syntaksen for å definere oppregningstypen, la oss se på et eksempel:



enumFeil{
IO_ERROR,
DISK_ERROR,
NETTVERKSFEIL
};

Enum -søkeordet må alltid brukes til å definere oppregningstypen. Så når du vil definere en oppregningstype, må du bruke søkeordet enum før. Etter enum -søkeordet må du bruke en gyldig identifikator for å definere.



I eksemplet ovenfor vil kompilatoren tilordne 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, den neste enum-element tildeles verdien 1, og så videre.





Denne standardatferden kan endres om nødvendig ved å tildele den konstante integrale verdien eksplisitt som følger:

enumFeil{
IO_ERROR= 2,
DISK_ERROR,
NETTVERKSFEIL= 8 ,
PRINT_ERROR
};

I dette tilfellet er IO_ERROR eksplisitt tilordnet verdien 2 av programmereren, DISK_ERROR er tilordnet verdien 3 av kompilatoren, NETWORK_ERROR er eksplisitt tilordnet verdien 8 av programmereren, og PRINT_ERROR er tilordnet den neste integralverdi av det forrige enum -elementet NETWORK_ERROR (dvs. 9) av kompilatoren.



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

enumFeil Hw_Error;

Igjen, enum er nøkkelordet her, Feil er enumtypen, og Hw_Error er en enumvariabel.

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

  • Eksempel 1: Standard bruk av enum definisjon
  • Eksempel 2: Egendefinert bruk av enum definisjon
  • Eksempel 3: enum definisjon ved bruk av konstant uttrykk
  • Eksempel 4: enum omfang

Eksempel 1: Standard enum Definisjon Bruk

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

#inkludere

/ * Definer enumtypen */
enumFeil{
IO_ERROR,
DISK_ERROR,
NETTVERKSFEIL
};

inthoved-()
{
enumFeil Hw_Error; /* Opprette enum -variabel*/

printf ('Innstiller Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til NETWORK_ERROR n');
Hw_Error=NETTVERKSFEIL;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

komme tilbake 0;
}

https://lh6.googleusercontent.com/0CHtUqkuIA-okDEPI0_5fZLU6lZ6Exz6DK4uUr63k5Ros863eqC-HmrvZ_LZBKbEvqeCVMCsnvXXhfrYJrBzxzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzZzz

Eksempel 2: Custom Enum Definition Usage

I dette eksemplet lærer du hvordan du definerer oppregningstypen med en tilpasset konstant verdi. Dette eksemplet vil også hjelpe deg med å forstå hvordan initialisering av tilpassede konstanter kan utføres i vilkårlig rekkefølge. I dette eksemplet har vi eksplisitt definert den konstante verdien for 1stog 3rdenum -elementer (dvs. henholdsvis IO_ERROR og NETWORK_ERROR), men vi har hoppet over den eksplisitte initialiseringen for 2ndog 4thelementer. Det er nå kompilatorens ansvar å tildele standardverdiene til 2ndog 4thenum -elementer (dvs. henholdsvis DISK_ERROR og PRINT_ERROR). DISK_ERROR vil bli tildelt verdien 3 og PRINT_ERROR vil bli tildelt verdien 9. Nedenfor ser du eksempelprogrammet og utdataene.

#inkludere

/* Definer enumtypen - Tilpasset initialisering*/
enumFeil{
IO_ERROR= 2,
DISK_ERROR,
NETTVERKSFEIL= 8,
PRINT_ERROR
};

inthoved-()
{

/* Erklær enum variabel*/
enumFeil Hw_Error;

printf ('Innstiller Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til NETWORK_ERROR n');
Hw_Error=NETTVERKSFEIL;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

komme tilbake 0;
}

https://lh6.googleusercontent.com/hKtv00Hj7iPnnlNhC7mu1v7hzPhB64C9nyHwjB6oQgyCyEwOgiLSYWDOxvQCDrhumn4IzqhkN4qF9HcUFKafKFKFKFKFKfKfKfKfKfKfKfKvKfKvKfKvKfKvKfKvfKvKfKvFjKvKvKfKvKvKvKvKvKvKvKvKvfKvfKvfKvfKvfKvfKvKvfKvfVrVfKvKvKvKvFrVfKvKvVrVxVvKvfKvVrKvVrKvVrVrKvVrVrKvVrVrXv

Eksempel 3: Enum Definition Using Constant Expression

I dette eksemplet lærer du hvordan du bruker det konstante uttrykket til å definere den konstante verdien 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 enumelementene på; imidlertid dette
programmet viser at denne måten å initialisere enumelementer er mulig i c.
* /


enumFeil{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETTVERKSFEIL= 2 == 2,
PRINT_ERROR
};

inthoved-()
{

/* Erklær enum variabel*/
enumFeil Hw_Error;

printf ('Innstiller Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til NETWORK_ERROR n');
Hw_Error=NETTVERKSFEIL;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

komme tilbake 0;
}

https://lh4.googleusercontent.com/9FAbPOnM95LiP_UQvg40oHSW4sv34aqpFgasbHMiy06Z_rKEom81TuMCVsfxWaZedtQOMEQx7ef_5qEfRVcNrUvhitDzOcTvOilby1Xreg

Eksempel 4: enum Omfang

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

#inkludere

inthoved-()
{

/ * Definer enumtypen */
enumFeil_1{
IO_ERROR= 10,
DISK_ERROR,
NETTVERKSFEIL= 3,
PRINT_ERROR
};


{

/* Definer enumtypen i det indre omfanget*/
enumFeil_1{
IO_ERROR= tjue,
DISK_ERROR,
NETTVERKSFEIL= 35,
PRINT_ERROR
};

/* Erklær enum variabel*/
enumFeil_1 Hw_Error;
printf ('Innstiller Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til NETWORK_ERROR n');
Hw_Error=NETTVERKSFEIL;
printf ('Verdi av Hw_Error = %d n',Hw_Error);

printf (' nAngir Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Verdi av Hw_Error = %d n',Hw_Error);
}
komme tilbake 0;
}

Sammenligning mellom enum og makro

Enum Makro
Omfangsregel gjelder for enum. Omfangsregel gjelder ikke for makro.
Standard Enum -verditildeling skjer automatisk.

Enum er svært nyttig for å 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 konstantverdi manuelt mens du 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 makro for store programvareutviklingsprosjekter. Dette hjelper med å skrive rene og lesbare programmer.