Hvordan bruke enum på C -språk

Hvordan bruke enum på C -språk
Enum -programmet på C -programmeringsspråket brukes til å definere integrerte konstante verdier, noe som er veldig nyttig med å skrive rene og lesbare programmer. Programmerere bruker normalt oppregning for å definere navngitte integrerte konstanter i programmene sine for å gi bedre lesbarhet og vedlikeholdbarhet 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 av 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).

Dypt dykk i enum

Nå, siden vi kjenner syntaksen for å definere oppregningen, la oss se på et eksempel:

enum feil
Io_error,
Disk_error,
NETTVERKSFEIL
;

Nøkkelordet "Enum" må alltid brukes til å definere oppregningen. 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 tilordne IO_ERROR til den integrerte verdien: 0, disk_error til den integrerte verdien: 1 og nettverk_error til den integrerte verdien: 2. Som standard tildeles den første enumelementet alltid verdien 0, den neste enum-elementet tildeles verdien 1, og så videre.

Denne standardoppførselen kan endres om nødvendig ved å tilordne den konstante integrerte verdien eksplisitt, som følger:

enum feil
Io_error = 2,
Disk_error,
Network_error = 8 ,
Print_error
;

I dette tilfellet er IO_ERROR eksplisitt tildelt en verdi av 2 av programmereren, Disk_error tildeles en verdi av 3 av kompilatoren, Network_Error tildeles eksplisitt verdien av 8 av programmereren, og Print_error er tilordnet den neste Integrert verdi av forrige enumelement Network_Error (i.e., 9) av kompilatoren.

Så du forstår nå hvordan du kan definere 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 enumvariabelen som følger:

enum feil hw_error;

Igjen, "enum" er nøkkelordet her, "feil" er enum -typen, og "hw_error" er en enumvariabel.

Vi vil nå se på følgende eksempler for å forstå de forskjellige bruken av enum:

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

Eksempel 1: Standard enum definisjon bruk

I dette eksemplet lærer du hvordan du definerer oppregningen med standard konstante verdier. Kompilatoren vil ta seg av å tilordne standardverdiene til Enum -elementene. Nedenfor vil du se eksempelprogrammet og tilsvarende utgang.

#inkludere
/ * Definere enum -typen */
enum feil
Io_error,
Disk_error,
NETTVERKSFEIL
;
int main ()

enum feil hw_error; /* Opprette enumvariabel*/
printf ("Setting hw_error til io_error \ n");
Hw_error = io_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error til nettverk_error \ n");
Hw_error = nettverk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
retur 0;

Eksempel 2: Tilpasset enum definisjon bruk

I dette eksemplet lærer du hvordan du definerer oppregningen med en tilpasset konstant verdi. Dette eksemplet vil også hjelpe deg å forstå hvordan den tilpassede konstanten initialiseringen kan gjøres i enhver tilfeldig rekkefølge. I dette eksemplet har vi eksplisitt definert den konstante verdien for 1st og 3Rd enum elementer (jeg.e., Henholdsvis IO_ERROR og Network_Error), men vi har hoppet over den eksplisitte initialiseringen for de 2nd og 4th elementer. Det er nå kompilatorens ansvar å tilordne standardverdiene til 2nd og 4th enum elementer (jeg.e., Disk_error og print_error, henholdsvis). Disk_error vil bli tildelt en verdi av 3 og print_error vil bli tildelt en verdi av 9. Nedenfor vil du se eksempelprogrammet og utdataene.

#inkludere
/* Definer enum -typen - tilpasset initialisering*/
enum feil
Io_error = 2,
Disk_error,
Network_error = 8,
Print_error
;
int main ()

/* Erklære enumvariabel*/
enum feil hw_error;
printf ("Setting hw_error til io_error \ n");
Hw_error = io_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error til nettverk_error \ n");
Hw_error = nettverk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to print_error \ n");
Hw_error = print_error;
printf ("Verdien 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 det konstante uttrykket for å definere den konstante verdien for enumelementer.

#inkludere
/* Definer Enum -typen - 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
Program viser at denne måten med enumelementer initialisering er mulig i C.
*/
enum feil
Io_error = 1 + 2 * 3 + 4,
Disk_error,
Network_error = 2 == 2,
Print_error
;
int main ()

/* Erklære enumvariabel*/
enum feil hw_error;
printf ("Setting hw_error til io_error \ n");
Hw_error = io_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error til nettverk_error \ n");
Hw_error = nettverk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to print_error \ n");
Hw_error = print_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
retur 0;

Eksempel 4: Enum omfang

I dette eksemplet vil du lære hvordan scoping -regelen fungerer for enum. En makro (#defin) kunne ha blitt brukt til å definere en konstant i stedet for enum, men scoping -regelen fungerer ikke for makro.

#inkludere
int main ()

/ * Definere enum -typen */
enum error_1
Io_error = 10,
Disk_error,
Network_error = 3,
Print_error
;

/* Definere enum -typen i det indre omfanget*/
enum error_1
Io_error = 20,
Disk_error,
Network_error = 35,
Print_error
;
/* Erklære enumvariabel*/
enum error_1 hw_error;
printf ("Setting hw_error til io_error \ n");
Hw_error = io_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to disk_error \ n");
Hw_error = disk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error til nettverk_error \ n");
Hw_error = nettverk_error;
printf ("Verdien av hw_error = %d \ n", hw_error);
printf ("\ nseting hw_error to print_error \ n");
Hw_error = print_error;
printf ("Verdien av hw_error = %d \ n", hw_error);

retur 0;

Sammenligning mellom enum og makro

Enum Makro
Omfangsregel er aktuelt for enum. Omfangsregel er ikke aktuelt for makro.
Standard enumverdioppgave skjer automatisk.

Enum er veldig nyttig i å definere et stort antall konstanter. Kompilatoren tar standardinitialisering 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 konstant verdi 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.