Syntaks
enum <Enum Type Navn> {Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-n,
};
Standardværdien for Enumeration_Constant_Element-1 er 0, værdien af Enumeration_Constant_Element-2 er 1, værdien af Enumeration_Constant_Element-3 er 2, og værdien af Enumeration_Constant_Element-n er (n-1).
Dyk dybt ned i Enum
Da vi nu kender syntaksen til at definere optællingstypen, lad os se på et eksempel:
enumFejl{
IO_ERROR,
DISK_ERROR,
NETVÆRKSFEJL
};
Enum -søgeordet skal altid bruges til at definere optællingstypen. Så når du vil definere en optællingstype, skal du bruge enum -søgeordet før. Efter enum -søgeordet skal du bruge en gyldig identifikator til at definere.
I ovenstående eksempel tildeler kompilatoren IO_ERROR til integralværdien: 0, DISK_ERROR til integralværdien: 1 og NETWORK_ERROR til integralværdien: 2. Som standard tildeles det første enum-element altid værdien 0, den næste enum-element tildeles værdien 1, og så videre.
Denne standardadfærd kan om nødvendigt ændres ved eksplicit at tildele den konstante integrale værdi som følger:
enumFejl{IO_ERROR= 2,
DISK_ERROR,
NETVÆRKSFEJL= 8 ,
PRINT_ERROR
};
I dette tilfælde tildeles IO_ERROR eksplicit til værdien 2 af programmereren, DISK_ERROR tildeles til værdien 3 af kompilatoren, NETWORK_ERROR tildeles eksplicit til værdien 8 af programmereren, og PRINT_ERROR tildeles den næste integralværdi af det tidligere enum -element NETWORK_ERROR (dvs. 9) af kompilatoren.
Så du forstår nu, hvordan du definerer en brugerdefineret optællingstype i C. Er det muligt at deklarere en variabel af enumtype (da vi kan deklarere en variabel af heltalstype)? Ja det er! Du kan erklære variablen enum som følger:
enumFejl Hw_Error;Igen er enum nøgleordet her, fejl er enumtypen, og Hw_Error er en enumvariabel.
Vi vil nu se på følgende eksempler for at forstå de forskellige anvendelser af enum:
- Eksempel 1: Standard brug af enum definition
- Eksempel 2: Brugerdefineret enum definition brug
- Eksempel 3: enum definition ved hjælp af konstant udtryk
- Eksempel 4: enum omfang
Eksempel 1: Standard enum Definition Usage
I dette eksempel lærer du, hvordan du definerer optællingstypen med standardkonstantværdier. Compileren sørger for at tildele standardværdierne til enumelementerne. Nedenfor ser du eksempelprogrammet og det tilhørende output.
#omfatte/ * Definer enumtypen */
enumFejl{
IO_ERROR,
DISK_ERROR,
NETVÆRKSFEJL
};
intvigtigste()
{
enumFejl Hw_Error; /* Oprettelse af enum variabel*/
printf ('Indstilling af Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til NETWORK_ERROR n');
Hw_Error=NETVÆRKSFEJL;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
Vend tilbage 0;
}
Eksempel 2: Brugerdefineret enum Definition
I dette eksempel lærer du, hvordan du definerer optællingstypen med en tilpasset konstant værdi. Dette eksempel hjælper dig også med at forstå, hvordan initialiseringen af brugerdefinerede konstanter kan udføres i vilkårlig rækkefølge. I dette eksempel har vi eksplicit defineret den konstante værdi for 1stog 3rdenum -elementer (dvs. henholdsvis IO_ERROR og NETWORK_ERROR), men vi har sprunget over den eksplicitte initialisering for de 2ndog 4thelementer. Det er nu kompilatorens ansvar at tildele standardværdierne til 2ndog 4thenum -elementer (dvs. henholdsvis DISK_ERROR og PRINT_ERROR). DISK_ERROR tildeles en værdi på 3, og PRINT_ERROR tildeles en værdi på 9. Nedenfor ser du eksempelprogrammet og output.
#omfatte/* Definer enumtypen - Tilpasset initialisering*/
enumFejl{
IO_ERROR= 2,
DISK_ERROR,
NETVÆRKSFEJL= 8,
PRINT_ERROR
};
intvigtigste()
{
/* Angiv enum variabel*/
enumFejl Hw_Error;
printf ('Indstilling af Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til NETWORK_ERROR n');
Hw_Error=NETVÆRKSFEJL;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
Vend tilbage 0;
}
Eksempel 3: Enum Definition ved hjælp af konstant udtryk
I dette eksempel lærer du, hvordan du bruger det konstante udtryk til at definere den konstante værdi for enum -elementer.
#omfatte/* Definer enumtypen - brugerdefineret initialisering ved hjælp af konstant udtryk
konstant udtryk bruges her i tilfælde af:
en. IO_ERROR og
b. NETVÆRKSFEJL
Dette er en usædvanlig måde at definere enumelementerne på; dog dette
program viser, at denne måde at initialisere enumelementer er mulig i c.
* /
enumFejl{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETVÆRKSFEJL= 2 == 2,
PRINT_ERROR
};
intvigtigste()
{
/* Angiv enum variabel*/
enumFejl Hw_Error;
printf ('Indstilling af Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til NETWORK_ERROR n');
Hw_Error=NETVÆRKSFEJL;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
Vend tilbage 0;
}
Eksempel 4: enum Omfang
I dette eksempel lærer du, hvordan omfangsreglen fungerer for enum. En MACRO (#define) kunne have været brugt til at definere en konstant i stedet for enum, men anvendelsesreglen fungerer ikke for MACRO.
#omfatteintvigtigste()
{
/ * Definer enumtypen */
enumFejl_1{
IO_ERROR= 10,
DISK_ERROR,
NETVÆRKSFEJL= 3,
PRINT_ERROR
};
{
/* Definer enumtypen i det indre omfang*/
enumFejl_1{
IO_ERROR= tyve,
DISK_ERROR,
NETVÆRKSFEJL= 35,
PRINT_ERROR
};
/* Angiv enum variabel*/
enumFejl_1 Hw_Error;
printf ('Indstilling af Hw_Error til IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til NETWORK_ERROR n');
Hw_Error=NETVÆRKSFEJL;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
printf (' nIndstilling af Hw_Error til PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Værdien af Hw_Error = %d n',Hw_Error);
}
Vend tilbage 0;
}
Sammenligning mellem enum og makro
| Enum | Makro |
| Omfangsregel gælder for enum. | Omfangsregel gælder ikke for makro. |
| Standard Enum -værditildeling sker automatisk. Enum er meget nyttig til at definere et stort antal konstanter. Compileren tager standardinitialisering af konstantværdien. | Makrokonstantværdierne skal altid nævnes eksplicit af programmøren. Dette kan være en kedelig proces for et stort antal konstanter, da programmøren altid skal definere hver konstant værdi manuelt, mens makroen defineres. |
Konklusion
Enum-programmet i C kan betragtes som en valgfri metode til selvstændige programmer eller små projekter, da programmører altid kan bruge makro i stedet for et enum. Imidlertid har erfarne programmører en tendens til at bruge enum over makro til store softwareudviklingsprojekter. Dette hjælper med at skrive rene og læsbare programmer.