Syntaxis
opsomming <Enum-typenaam> {Opsomming_Constant_Element-1,
Opsomming_Constant_Element-2,
Opsomming_Constant_Element-3,
…… ...........,
Opsomming_Constant_Element-N,
};
De standaardwaarde van Enumeration_Constant_Element-1 is 0, de waarde van Enumeration_Constant_Element-2 is 1, de waarde van Enumeration_Constant_Element-3 is 2 en de waarde van Enumeration_Constant_Element-n is (n-1).
Diep duiken in Enum
Nu we de syntaxis kennen om het opsommingstype te definiëren, laten we een voorbeeld bekijken:
opsommingFout{
IO_ERROR,
DISK_ERROR,
NETWERKFOUT
};
Het sleutelwoord enum moet altijd worden gebruikt om het type opsomming te definiëren. Dus wanneer u een enumeratietype wilt definiëren, moet u het trefwoord enum vóór gebruiken. Na het trefwoord enum moet u een geldige id gebruiken om de .
In het bovenstaande voorbeeld wijst de compiler IO_ERROR toe aan de integrale waarde: 0, DISK_ERROR aan de integrale waarde: 1 en NETWORK_ERROR aan de integrale waarde: 2. Standaard krijgt het eerste enum-element altijd de waarde 0, het volgende enum-element krijgt de waarde 1, enzovoort.
Dit standaardgedrag kan indien nodig worden gewijzigd door de constante integraalwaarde expliciet als volgt toe te wijzen:
opsommingFout{IO_ERROR= 2,
DISK_ERROR,
NETWERKFOUT= 8 ,
PRINT_ERROR
};
In dit geval wordt de IO_ERROR expliciet toegewezen aan een waarde van 2 door de programmeur, DISK_ERROR wordt toegewezen aan een waarde van 3 door de compiler, NETWORK_ERROR wordt expliciet toegewezen aan de waarde 8 door de programmeur en PRINT_ERROR wordt toegewezen aan de volgende integrale waarde van het vorige enum-element NETWORK_ERROR (dwz 9) door de compiler.
U begrijpt nu hoe u een door de gebruiker gedefinieerd enumeratietype in C definieert. Is het mogelijk om een variabele van het type opsomming te declareren (zoals we een variabele van het type integer kunnen declareren)? Jazeker! U kunt de variabele enum als volgt declareren:
opsommingFout Hw_Error;Nogmaals, enum is hier het sleutelwoord, Error is het enum-type en Hw_Error is een enum-variabele.
We zullen nu naar de volgende voorbeelden kijken om de verschillende gebruiken van enum te begrijpen:
- Voorbeeld 1: Standaard gebruik van opsommingsdefinitie
- Voorbeeld 2: Gebruik van aangepaste opsommingsdefinitie
- Voorbeeld 3: enum-definitie met constante uitdrukking
- Voorbeeld 4: opsommingsbereik
Voorbeeld 1: Standaard opsomming Definitie Gebruik
In dit voorbeeld leert u hoe u het opsommingstype definieert met standaard constante waarden. De compiler zorgt voor het toewijzen van de standaardwaarden aan de enum-elementen. Hieronder ziet u het voorbeeldprogramma en de bijbehorende uitvoer.
#erbij betrekken/* Definieer het opsommingstype */
opsommingFout{
IO_ERROR,
DISK_ERROR,
NETWERKFOUT
};
inthoofd()
{
opsommingFout Hw_Error; /* Enum-variabele maken*/
printf ('Hw_Error instellen op IO_ERRORN');
Hw_Fout=IO_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op DISK_ERRORN');
Hw_Fout=DISK_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op NETWORK_ERRORN');
Hw_Fout=NETWERKFOUT;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
opbrengst 0;
}
Voorbeeld 2: Aangepaste opsomming Definitie Gebruik
In dit voorbeeld leert u hoe u het opsommingstype definieert met een aangepaste constante waarde. Dit voorbeeld helpt u ook te begrijpen hoe de initialisatie van aangepaste constanten in willekeurige volgorde kan worden uitgevoerd. In dit voorbeeld hebben we expliciet de constante waarde gedefinieerd voor de 1NSen 3rdenum-elementen (d.w.z. respectievelijk IO_ERROR en NETWORK_ERROR), maar we hebben de expliciete initialisatie voor de 2 overgeslagennden 4eelementen. Het is nu de verantwoordelijkheid van de compiler om de standaardwaarden toe te wijzen aan de 2nden 4eenum-elementen (d.w.z. respectievelijk DISK_ERROR en PRINT_ERROR). DISK_ERROR krijgt de waarde 3 en PRINT_ERROR krijgt de waarde 9. Hieronder ziet u het voorbeeldprogramma en de uitvoer.
#erbij betrekken/* Definieer het enum-type - Aangepaste initialisatie*/
opsommingFout{
IO_ERROR= 2,
DISK_ERROR,
NETWERKFOUT= 8,
PRINT_ERROR
};
inthoofd()
{
/* Declareer enum variabele*/
opsommingFout Hw_Error;
printf ('Hw_Error instellen op IO_ERRORN');
Hw_Fout=IO_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op DISK_ERRORN');
Hw_Fout=DISK_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op NETWORK_ERRORN');
Hw_Fout=NETWERKFOUT;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op PRINT_ERRORN');
Hw_Fout=PRINT_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
opbrengst 0;
}
Voorbeeld 3: Enum-definitie met behulp van constante expressie
In dit voorbeeld leert u hoe u de constante-expressie gebruikt om de constante waarde voor enum-elementen te definiëren.
#erbij betrekken/* Definieer het enum-type - aangepaste initialisatie met constante expressie
constante expressie wordt hier gebruikt in het geval van:
A. IO_ERROR en
B. NETWERKFOUT
Dit is een ongebruikelijke manier om de enum-elementen te definiëren; echter, dit
programma laat zien dat deze manier van enum elementen initialisatie mogelijk is in c.
* /
opsommingFout{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
NETWERKFOUT= 2 == 2,
PRINT_ERROR
};
inthoofd()
{
/* Declareer enum variabele*/
opsommingFout Hw_Error;
printf ('Hw_Error instellen op IO_ERRORN');
Hw_Fout=IO_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op DISK_ERRORN');
Hw_Fout=DISK_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op NETWORK_ERRORN');
Hw_Fout=NETWERKFOUT;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op PRINT_ERRORN');
Hw_Fout=PRINT_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
opbrengst 0;
}
Voorbeeld 4: enum Scope
In dit voorbeeld leert u hoe de scopingregel werkt voor enum. Een MACRO (#define) had kunnen worden gebruikt om een constante te definiëren in plaats van de enum, maar de scopingregel werkt niet voor MACRO.
#erbij betrekkeninthoofd()
{
/* Definieer het opsommingstype */
opsommingError_1{
IO_ERROR= 10,
DISK_ERROR,
NETWERKFOUT= 3,
PRINT_ERROR
};
{
/* Definieer het enum type in de inner scope*/
opsommingError_1{
IO_ERROR= twintig,
DISK_ERROR,
NETWERKFOUT= 35,
PRINT_ERROR
};
/* Declareer enum variabele*/
opsommingError_1 Hw_Error;
printf ('Hw_Error instellen op IO_ERRORN');
Hw_Fout=IO_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op DISK_ERRORN');
Hw_Fout=DISK_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op NETWORK_ERRORN');
Hw_Fout=NETWERKFOUT;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
printf ('NHw_Error instellen op PRINT_ERRORN');
Hw_Fout=PRINT_ERROR;
printf ('Waarde van Hw_Error = %dN',Hw_Fout);
}
opbrengst 0;
}
Vergelijking tussen enum en macro
| Enum | Macro |
| De scopingregel is van toepassing op enum. | Bereikregel is niet van toepassing op Macro. |
| De standaardtoewijzing van de Enum-waarde gebeurt automatisch. Enum is erg handig bij het definiëren van een groot aantal constanten. De compiler neemt de standaard initialisatie van de constante waarde. | De macroconstanten moeten altijd expliciet door de programmeur worden vermeld. Dit kan een vervelend proces zijn voor een groot aantal constanten, aangezien de programmeur elke constante waarde altijd handmatig moet definiëren tijdens het definiëren van de macro. |
Conclusie
Het enum-programma in C kan worden beschouwd als een optionele methode voor op zichzelf staande programma's of kleine projecten, omdat programmeurs altijd macro kunnen gebruiken in plaats van een enum. Ervaren programmeurs hebben echter de neiging om enum boven macro te gebruiken voor grootschalige softwareontwikkelingsprojecten. Dit helpt bij het schrijven van schone en leesbare programma's.