Cum se folosește enum în limbajul C.

How Use Enum C Language



Programul enum în limbajul de programare C este utilizat pentru a defini valorile constante integrale, ceea ce este foarte util în scrierea programelor curate și lizibile. Programatorii folosesc în mod normal enumerarea pentru a defini constante integrale numite în programele lor pentru a asigura o mai bună lizibilitate și o mai bună întreținere a software-ului. Acest articol va discuta enum în detaliu.

Sintaxă

enum <Nume tip enum> {
Enumerare_Constant_Element-1,
Enumerare_Constant_Element-2,
Enumerare_Constant_Element-3,
…… .........,
Enumerare_Constant_Element-n,
};

Valoarea implicită a Enumeration_Constant_Element-1 este 0, valoarea Enumeration_Constant_Element-2 este 1, valoarea Enumeration_Constant_Element-3 este 2, iar valoarea Enumeration_Constant_Element-n este (n-1).







Adânceste-te în Enum

Acum, deoarece știm sintaxa pentru a defini tipul de enumerare, să ne uităm la un exemplu:



enumEroare{
IO_ERROR,
DISK_ERROR,
EROARE DE REȚEA
};

Cuvântul cheie enum trebuie utilizat întotdeauna pentru a defini tipul de enumerare. Deci, ori de câte ori doriți să definiți un tip de enumerare, trebuie să utilizați cuvântul cheie enum înainte. După cuvântul cheie enum, trebuie să utilizați un identificator valid pentru a defini.



În exemplul de mai sus, compilatorul va atribui IO_ERROR la ​​valoarea integrală: 0, DISK_ERROR la ​​valoarea integrală: 1 și NETWORK_ERROR la ​​valoarea integrală: 2. În mod implicit, primului element enum i se atribuie întotdeauna valoarea 0, următorul enum-elementului i se atribuie valoarea 1 și așa mai departe.





Acest comportament implicit poate fi modificat, dacă este necesar, prin atribuirea explicită a valorii integrale constante, după cum urmează:

enumEroare{
IO_ERROR= 2,
DISK_ERROR,
EROARE DE REȚEA= 8 ,
PRINT_ERROR
};

În acest caz, IO_ERROR este atribuit în mod explicit unei valori de 2 de către programator, DISK_ERROR este atribuit unei valori de 3 de către compilator, NETWORK_ERROR este atribuit în mod explicit valorii de 8 de către programator, iar PRINT_ERROR este atribuit următoarei valoarea integrală a elementului anterior enumerat NETWORK_ERROR (adică, 9) de către compilator.



Deci, acum înțelegeți cum să definiți un tip de enumerare definit de utilizator în C. Este posibil să declarați o variabilă de tip enum (așa cum putem declara o variabilă de tip întreg)? Da, este! Puteți declara variabila enum după cum urmează:

enumEroare Hw_Error;

Din nou, enum este cuvântul cheie aici, Error este tipul enum și Hw_Error este o variabilă enum.

Vom analiza acum următoarele exemple pentru a înțelege diferitele utilizări ale enum:

  • Exemplul 1: utilizarea implicită a definiției enum
  • Exemplul 2: utilizarea definiției enum personalizate
  • Exemplul 3: definirea enum folosind expresie constantă
  • Exemplul 4: enum scope

Exemplul 1: Enumere implicită Definiție Utilizare

În acest exemplu, veți afla cum să definiți tipul de enumerare cu valorile constante implicite. Compilatorul se va ocupa de atribuirea valorilor implicite elementelor enum. Mai jos, veți vedea exemplul de program și ieșirea corespunzătoare.

#include

/ * Definiți tipul de enumere * /
enumEroare{
IO_ERROR,
DISK_ERROR,
EROARE DE REȚEA
};

intprincipal()
{
enumEroare Hw_Error; / * Crearea variabilei enum *

printf ('Setarea Hw_Error la IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la NETWORK_ERROR n');
Hw_Error=EROARE DE REȚEA;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

întoarcere 0;
}

https://lh6.googleusercontent.com/0CHtUqkuIA-okDEPI0_5fZLU6lZ6Exz6DK4uUr63k5Ros863eqC-HmrvZ_LZBKbEvqeCVMCsnvXXhfrYJrBaxxfZBWoiMOhzApzXey4uUr63k5Ros863eqC-HmrvZ_LZBKbEvqeCVMCsnvXXhfrYJrBaxxfZBVoiMOhzAQPzXey4

Exemplul 2: Utilizarea definiției enumului personalizat

În acest exemplu, veți afla cum să definiți tipul de enumerare cu o valoare constantă personalizată. De asemenea, acest exemplu vă va ajuta să înțelegeți cum se poate face inițializarea constantelor personalizate în orice ordine aleatorie. În acest exemplu, am definit în mod explicit valoarea constantă pentru 1Sfși 3rdelemente enum (adică IO_ERROR și, respectiv, NETWORK_ERROR), dar am omis inițializarea explicită pentru 2ndși 4aelemente. Acum este responsabilitatea compilatorului de a atribui valorile implicite celor 2ndși 4aelemente enum (adică DISK_ERROR și PRINT_ERROR, respectiv). DISK_ERROR va fi atribuit unei valori de 3 și PRINT_ERROR va fi atribuit unei valori de 9. Mai jos, veți vedea exemplul de program și ieșirea.

#include

/ * Definiți tipul enum - Initializare personalizată * /
enumEroare{
IO_ERROR= 2,
DISK_ERROR,
EROARE DE REȚEA= 8,
PRINT_ERROR
};

intprincipal()
{

/ * Declarați variabila enum *
enumEroare Hw_Error;

printf ('Setarea Hw_Error la IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la NETWORK_ERROR n');
Hw_Error=EROARE DE REȚEA;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

întoarcere 0;
}

https://lh6.googleusercontent.com/hKtv00Hj7iPnnlNhC7mu1v7hzPhB64C9nyHwjB6oQgyCyEwOgiLSYWDOxvQCDrhumn4IzqhkN4qF9HcuGZ9thqlBLy6wzwzwxwl

Exemplul 3: Definiția Enum folosind expresia constantă

În acest exemplu, veți învăța cum să utilizați expresia constantă pentru a defini valoarea constantă pentru elementele enum.

#include

/ * Definiți tipul enum - inițializare personalizată utilizând expresie constantă
expresia constantă este utilizată aici în cazul:
A. IO_ERROR și
b. EROARE DE REȚEA
Acesta este un mod neobișnuit de a defini elementele enum; cu toate acestea, aceasta
programul demonstrează că acest mod de inițializare a elementelor enum este posibil în c.
* /


enumEroare{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
EROARE DE REȚEA= 2 == 2,
PRINT_ERROR
};

intprincipal()
{

/ * Declarați variabila enum *
enumEroare Hw_Error;

printf ('Setarea Hw_Error la IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la NETWORK_ERROR n');
Hw_Error=EROARE DE REȚEA;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

întoarcere 0;
}

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

Exemplul 4: Enum Scope

În acest exemplu, veți afla cum funcționează regula enumerării pentru enum. Un MACRO (#define) ar fi putut fi folosit pentru a defini o constantă în loc de enum, dar regula de scop nu funcționează pentru MACRO.

#include

intprincipal()
{

/ * Definiți tipul de enumere * /
enumEroare_1{
IO_ERROR= 10,
DISK_ERROR,
EROARE DE REȚEA= 3,
PRINT_ERROR
};


{

/ * Definiți tipul enum în domeniul interior * /
enumEroare_1{
IO_ERROR= douăzeci,
DISK_ERROR,
EROARE DE REȚEA= 35,
PRINT_ERROR
};

/ * Declarați variabila enum *
enumEroare_1 Hw_Error;
printf ('Setarea Hw_Error la IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la NETWORK_ERROR n');
Hw_Error=EROARE DE REȚEA;
printf ('Valoarea Hw_Error =% d n',Hw_Error);

printf (' nSetarea Hw_Error la PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valoarea Hw_Error =% d n',Hw_Error);
}
întoarcere 0;
}

Comparație între enum și macro

Enum Macro
Regula de acoperire este aplicabilă pentru enum. Regula de acoperire nu se aplică pentru Macro.
Atribuirea implicită a valorii Enum are loc automat.

Enum este foarte util în definirea unui număr mare de constante. Compilatorul preia inițializarea valorii constante implicite.

Valorile constantei macro trebuie întotdeauna menționate în mod explicit de către programator.

Acesta ar putea fi un proces obositor pentru un număr mare de constante, deoarece programatorul trebuie întotdeauna să definească manual fiecare valoare constantă în timp ce definește macro-ul.

Concluzie

Programul enum din C ar putea fi considerat o metodă opțională pentru programe independente sau proiecte de dimensiuni mici, deoarece programatorii pot folosi întotdeauna macro în loc de enum. Cu toate acestea, programatorii cu experiență tind să folosească enum peste macro pentru proiecte de dezvoltare software la scară largă. Acest lucru ajută la scrierea de programe curate și lizibile.