Phenquestions
Syntaxis
opsommingOpsomming_Constant_Element-1,
Opsomming_Constant_Element-2,
Opsomming_Constant_Element-3,
… ,
Enumeration_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).
Duik diep in Enum
Nu we de syntaxis kennen om het opsommingstype te definiëren, laten we een voorbeeld bekijken:
enum FoutIO_ERROR,
DISK_ERROR,
NETWERKFOUT
;
Het sleutelwoord "enum" moet altijd worden gebruikt om het type opsomming te definiëren define. Dus wanneer u een opsommingstype wilt definiëren, moet u eerst het trefwoord "enum" gebruiken
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:
enum FoutIO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 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 (i.e., 9) door de compiler.
U begrijpt nu dus hoe u een door de gebruiker gedefinieerd enumeratietype definieert in C. Is het mogelijk om een variabele van het type enum te declareren (zoals we een variabele van het type integer kunnen declareren)? Jawel! U kunt de variabele enum als volgt declareren:
enum Fout 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.
#include/* Definieer het opsommingstype */
enum Fout
IO_ERROR,
DISK_ERROR,
NETWERKFOUT
;
int hoofd()
enum Fout Hw_Error; /* Enum-variabele maken*/
printf("Hw_Error instellen op IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
retourneer 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 1st en 3rd enum elementen (i.e., IO_ERROR en NETWORK_ERROR, respectievelijk), maar we hebben de expliciete initialisatie voor de 2 overgeslagennd en 4dit elementen. Het is nu de verantwoordelijkheid van de compiler om de standaardwaarden toe te wijzen aan de 2nd en 4dit enum elementen (i.e., DISK_ERROR en PRINT_ERROR, respectievelijk). DISK_ERROR wordt toegewezen aan een waarde van 3 en PRINT_ERROR wordt toegewezen aan een waarde van 9. Hieronder ziet u het voorbeeldprogramma en de uitvoer.
#include/* Definieer het enum-type - Aangepaste initialisatie*/
enum Fout
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int hoofd()
/* Declareer enum variabele*/
enum Fout Hw_Error;
printf("Hw_Error instellen op IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
retourneer 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.
#include/* Definieer het enum-type - aangepaste initialisatie met constante expressie
constante expressie wordt hier gebruikt in het geval van:
een. 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 initialisatie van enum-elementen mogelijk is in c.
*/
enum Fout
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int hoofd()
/* Declareer enum variabele*/
enum Fout Hw_Error;
printf("Hw_Error instellen op IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
retourneer 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.
#includeint hoofd()
/* Definieer het opsommingstype */
opsomming Error_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;
/* Definieer het enum type in de inner scope*/
opsomming Error_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/* Declareer enum variabele*/
enum Error_1 Hw_Error;
printf("Hw_Error instellen op IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
printf("\nHw_Error instellen op PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Waarde van Hw_Error = %d \n",Hw_Error);
retourneer 0;
Vergelijking tussen enum en macro
| Enum | macro |
| De scopingregel is van toepassing op enum. | Bereikregel is niet van toepassing op Macro. |
| Standaardtoekenning 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 macroconstante waarden moeten altijd expliciet worden vermeld door de programmeur. 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.
