Hur man använder enum i C Language

Enum-programmet i programmeringsspråket C används för att definiera integrerade konstantvärden, vilket är till stor hjälp för att skriva rena och läsbara program. Programmerare använder normalt uppräkning för att definiera namngivna integralkonstanter i sina program för att ge bättre läsbarhet och underhåll av programvaran. Denna artikel kommer att diskutera enum i detalj.

Syntax

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

Standardvärdet för Enumeration_Constant_Element-1 är 0, värdet av Enumeration_Constant_Element-2 är 1, värdet av Enumeration_Constant_Element-3 är 2 och värdet av Enumeration_Constant_Element-n är (n-1).

Deep Dive in Enum

Nu, eftersom vi känner till syntaxen för att definiera uppräkningstypen, låt oss titta på ett exempel:

enum Error
IO_ERROR,
DISK_ERROR,
NÄTVERKSFEL
;

Nyckelordet "enum" måste alltid användas för att definiera uppräkningstypen. Så när du vill definiera en uppräkningstyp måste du använda nyckelordet "enum" innan . Efter nyckelordet "enum" måste du använda en giltig identifierare för att definiera .

I exemplet ovan tilldelar kompilatorn IO_ERROR till integralvärdet: 0, DISK_ERROR till integralvärdet: 1 och NETWORK_ERROR till integralvärdet: 2. Som standard tilldelas alltid det första enum-elementet värdet 0, nästa enum-element tilldelas värdet 1, och så vidare.

Det här standardbeteendet kan ändras vid behov genom att tilldela det konstanta integralvärdet uttryckligen enligt följande:

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

I detta fall tilldelas IO_ERROR uttryckligen värdet 2 av programmeraren, DISK_ERROR tilldelas värdet 3 av kompilatorn, NETWORK_ERROR tilldelas uttryckligen värdet 8 av programmeraren och PRINT_ERROR tilldelas nästa integrerat värde för det föregående enum-elementet NETWORK_ERROR (i.e., 9) av kompilatorn.

Så du förstår nu hur man definierar en användardefinierad uppräkningstyp i C. Är det möjligt att deklarera en variabel av enumtyp (eftersom vi kan deklarera en variabel av heltalstyp)? Ja det är det! Du kan deklarera enum-variabeln enligt följande:

enum Error Hw_Error;

Återigen är "enum" nyckelordet här, "Error" är enumtypen och "Hw_Error" är enum-variabel.

Vi kommer nu att titta på följande exempel för att förstå de olika användningarna av enum:

Exempel 1: Standardanvändning av enumdefinition
Exempel 2: Anpassad enumdefinition
Exempel 3: enumdefinition med konstant uttryck
Exempel 4: enum scope

Exempel 1: Standard enum Definition Usage

I det här exemplet lär du dig hur du definierar uppräkningstypen med standardkonstantvärden. Kompilatorn tar hand om att tilldela standardvärdena till enum-elementen. Nedan ser du exempelprogrammet och motsvarande utdata.

#omfatta
/ * Definiera enumtyp * /
enum Error
IO_ERROR,
DISK_ERROR,
NÄTVERKSFEL
;
int main ()

enum Error Hw_Error; / * Skapa enum-variabel * /
printf ("Ställ in Hw_Error till IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
returnera 0;

Exempel 2: Definition av anpassad användning

I det här exemplet lär du dig hur du definierar uppräkningstypen med ett anpassat konstantvärde. Det här exemplet hjälper dig också att förstå hur initialiseringen av anpassade konstanter kan göras i valfri slumpmässig ordning. I det här exemplet har vi uttryckligen definierat konstantvärdet för 1^st och 3^rd enum-element (i.e., IO_ERROR respektive NETWORK_ERROR), men vi har hoppat över den uttryckliga initialiseringen för de 2^nd och 4^th element. Det är nu kompilatorns ansvar att tilldela standardvärdena till 2^nd och 4^th enum-element (i.e., DISK_ERROR respektive PRINT_ERROR). DISK_ERROR tilldelas värdet 3 och PRINT_ERROR tilldelas värdet 9. Nedan ser du exempelprogrammet och utdata.

#omfatta
/ * Definiera enumtyp - Anpassad initialisering * /
enum Error
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int main ()

/ * Förklara enum-variabel * /
enum Error Hw_Error;
printf ("Ställer in Hw_Error till IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
returnera 0;

Exempel 3: Enumdefinition med konstant uttryck

I det här exemplet lär du dig hur du använder det konstanta uttrycket för att definiera det konstanta värdet för enum-element.

#omfatta
/ * Definiera enumtyp - anpassad initialisering med konstant uttryck
konstant uttryck används här vid:
a. IO_ERROR och
b. NÄTVERKSFEL
Detta är ett ovanligt sätt att definiera enum-elementen; dock detta
programmet visar att detta sätt att initiera enum-element är möjligt i c.
* /
enum Error
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Förklara enum-variabel * /
enum Error Hw_Error;
printf ("Ställer in Hw_Error till IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
returnera 0;

Exempel 4: Enum Scope

I det här exemplet lär du dig hur omfattningsregeln fungerar för enum. En MACRO (#define) kunde ha använts för att definiera en konstant istället för enum, men scoping-regeln fungerar inte för MACRO.

#omfatta
int main ()

/ * Definiera enumtyp * /
enum Error_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Definiera enumtypen i det inre omfånget * /
enum Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Förklara enum-variabel * /
enum Error_1 Hw_Error;
printf ("Ställer in Hw_Error till IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);
printf ("\ nStälla in Hw_Error till PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Värde för Hw_Error =% d \ n", Hw_Error);

returnera 0;

Jämförelse mellan enum och makro

Enum

Makro

Omfattningsregel gäller för enum.

Omfattningsregel är inte tillämplig för makro.

Standard Enum-värde tilldelning sker automatiskt.

Enum hjälper till att definiera ett stort antal konstanter. Kompilatorn tar standardinställningen för konstant värde.

Makrokonstantvärdena måste alltid nämnas uttryckligen av programmeraren.

Detta kan vara en tråkig process för ett stort antal konstanter eftersom programmeraren alltid måste manuellt definiera varje konstant värde samtidigt som makroen definieras.

Slutsats

Enum-programmet i C kan betraktas som en valfri metod för fristående program eller små projekt eftersom programmerare alltid kan använda makro istället för ett enum. Men erfarna programmerare brukar använda enum over macro för stora programvaruutvecklingsprojekt. Detta hjälper till att skriva rena och läsbara program.