Hur man använder enum på C -språk

How Use Enum C Language



Enum -programmet på programmeringsspråket C används för att definiera integrala konstanta vä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ållbarhet för programvaran. Denna artikel kommer att diskutera enum i detalj.

Syntax

enum <Enumtypnamn> {
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 för Enumeration_Constant_Element-2 är 1, värdet för Enumeration_Constant_Element-3 är 2 och värdet för Enumeration_Constant_Element-n är (n-1).







Dyk ner i Enum

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



enumFel{
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 innan. Efter enum -nyckelordet måste du använda en giltig identifierare för att definiera.



I exemplet ovan kommer kompilatorn att tilldela 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.





Detta standardbeteende kan ändras om det behövs genom att tilldela det konstanta integralvärdet uttryckligen enligt följande:

enumFel{
IO_ERROR= 2,
DISK_ERROR,
NÄTVERKSFEL= 8 ,
PRINT_ERROR
};

I detta fall tilldelas IO_ERROR uttryckligen till 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 integralvärdet för det tidigare enum -elementet NETWORK_ERROR (dvs 9) av kompilatorn.



Så du förstår nu hur du 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:

enumFel Hw_Error;

Återigen är enum nyckelordet här, Fel är enumtypen och Hw_Error är en enumvariabel.

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

  • Exempel 1: Standard användning av enum definition
  • Exempel 2: Anpassad användning av enum definition
  • Exempel 3: enum definition 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 enumelementen. Nedan ser du exempelprogrammet och motsvarande utdata.

#omfatta

/ * Definiera enumtyp */
enumFel{
IO_ERROR,
DISK_ERROR,
NÄTVERKSFEL
};

inthuvud()
{
enumFel Hw_Error; /* Skapar enum -variabel*/

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äller in Hw_Error till DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till NETWORK_ERROR n');
Hw_Error=NÄTVERKSFEL;
printf ('Värde för Hw_Error = %d n',Hw_Error);

lämna tillbaka 0;
}

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

Exempel 2: Anpassad enum Definition Användning

I det här exemplet lär du dig hur du definierar uppräkningstypen med ett anpassat konstant värde. Det här exemplet hjälper dig också att förstå hur initieringen av anpassade konstanter kan göras i valfri slumpmässig ordning. I det här exemplet har vi uttryckligen definierat det konstanta värdet för 1stoch 3rdenum -element (dvs. IO_ERROR respektive NETWORK_ERROR), men vi har hoppat över den uttryckliga initialiseringen för 2ndoch 4thelement. Det är nu kompilatorns ansvar att tilldela standardvärdena till 2: anndoch 4thenum -element (dvs. 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 enumtypen - Anpassad initialisering*/
enumFel{
IO_ERROR= 2,
DISK_ERROR,
NÄTVERKSFEL= 8,
PRINT_ERROR
};

inthuvud()
{

/* Deklarera enum variabel*/
enumFel 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äller in Hw_Error till DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till NETWORK_ERROR n');
Hw_Error=NÄTVERKSFEL;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

lämna tillbaka 0;
}

https://lh6.googleusercontent.com/hKtv00Hj7iPnnlNhC7mu1v7hzPhB64C9nyHwjB6oQgyCyEwOgiLSYWDOxvQCDrhumn4IzqhkN4qF9HcuGKafKFafKFKVafKfKfKfKVfKVfKfKVfKfKVfKfKVfKvKfKVfKvFjKvFjKvKvFjFjFjÖjVörVxVfKvKVfKvFjFjVjVjVsVjVxVvKvFjVxVjVsVjVsVjVsVjxvVsVjxvVrVxVxVjVxVjfrjVxVxVXVXVXVXVXVXVXJVXVXVXVXVXVXVXFj

Exempel 3: Enum definition 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 enumelement.

#omfatta

/* Definiera enumtypen - 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 enumelementen; dock detta
programmet visar att detta sätt att initialisera enumelement är möjligt i c.
* /


enumFel{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NÄTVERKSFEL= 2 == 2,
PRINT_ERROR
};

inthuvud()
{

/* Deklarera enum variabel*/
enumFel 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äller in Hw_Error till DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till NETWORK_ERROR n');
Hw_Error=NÄTVERKSFEL;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

lämna tillbaka 0;
}

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

Exempel 4: enum Omfattning

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 omfattningsregeln fungerar inte för MACRO.

#omfatta

inthuvud()
{

/ * Definiera enumtyp */
enumFel_1{
IO_ERROR= 10,
DISK_ERROR,
NÄTVERKSFEL= 3,
PRINT_ERROR
};


{

/* Definiera enumtypen i det inre omfånget*/
enumFel_1{
IO_ERROR= tjugo,
DISK_ERROR,
NÄTVERKSFEL= 35,
PRINT_ERROR
};

/* Deklarera enum variabel*/
enumFel_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äller in Hw_Error till DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till NETWORK_ERROR n');
Hw_Error=NÄTVERKSFEL;
printf ('Värde för Hw_Error = %d n',Hw_Error);

printf (' nStäller in Hw_Error till PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Värde för Hw_Error = %d n',Hw_Error);
}
lämna tillbaka 0;
}

Jämförelse mellan enum och makro

Enum Makro
Omfattningsregel gäller för enum. Omfattningsregel gäller inte för makro.
Standard Enum -värdetilldelning sker automatiskt.

Enum är till stor hjälp för 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 definiera varje konstant värde manuellt medan Macro 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 en enum. Erfarna programmerare brukar dock använda enum över makro för storskaliga mjukvaruutvecklingsprojekt. Detta hjälper till att skriva rena och läsbara program.