Programare C

Cum se folosește enum în limbajul C

Cum se folosește enum în limbajul C
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 constantele 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
Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumerare_Constant_Element-3,
.. ,
Enumeration_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:

enum Error
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ătorului element enum 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ă:

enum Error
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 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 (i.e., 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ă declarăm 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ă:

enum Eroare 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 enumului:

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

Exemplul 1: Enumere implicită Definiție Utilizare

În acest exemplu, veți învăța 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 enum *
enum Error
IO_ERROR,
DISK_ERROR,
EROARE DE REȚEA
;
int main ()

enum Eroare 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 = NETWORK_ERROR;
printf ("Valoarea Hw_Error =% d \ n", Hw_Error);
retur 0;

Exemplul 2: Utilizarea definiției enumului personalizat

În acest exemplu, veți învăța 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 3rd elemente enum (i.e., IO_ERROR și, respectiv, NETWORK_ERROR), dar am omis inițializarea explicită pentru 2nd și 4a elemente. Acum este responsabilitatea compilatorului de a atribui valorile implicite celor 2nd și 4a elemente enum (i.e., DISK_ERROR și, respectiv, PRINT_ERROR). DISK_ERROR va fi atribuit unei valori de 3, iar PRINT_ERROR va fi atribuit unei valori de 9. Mai jos, veți vedea exemplul de program și rezultatul.

#include
/ * Definiți tipul enum - Initializare personalizată * /
enum Error
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int main ()

/ * Declarați variabila enum *
enum Eroare 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 = NETWORK_ERROR;
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);
retur 0;

Exemplul 3: Definirea 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.
* /
enum Error
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Declarați variabila enum *
enum Eroare 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 = NETWORK_ERROR;
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);
retur 0;

Exemplul 4: enum Domeniu de aplicare

Î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
int main ()

/ * Definiți tipul enum *
enum Error_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Definiți tipul enum în domeniul interior * /
enum Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Declarați variabila enum *
enum Error_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 = NETWORK_ERROR;
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);

retur 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.

WinMouse lets you customize & improve mouse pointer movement on Windows PC
If you want to improve the default functions of your mouse pointer use freeware WinMouse. It adds more features to help you get the most out of your h...
Mouse left-click button not working on Windows 10
If you are using a dedicated mouse with your laptop, or desktop computer but the mouse left-click button is not working on Windows 10/8/7 for some rea...
Cursor jumps or moves randomly while typing in Windows 10
If you find that your mouse cursor jumps or moves on its own, automatically, randomly while typing in Windows laptop or computer, then some of these s...