Sintaxi
enum <Nom del tipus Enum> {Enumeració_Constant_Element-1,
Enumeració_Constant_Element-2,
Enumeració_Constant_Element-3,
...... .........,
Enumeració_Constant_Element-n,
};
El valor per defecte d'Enumeration_Constant_Element-1 és 0, el valor d'Enumeration_Constant_Element-2 és 1, el valor d'Enumeration_Constant_Element-3 és 2 i el valor d'Enumeration_Constant_Element-n és (n-1).
Submarinisme profund a Enum
Ara, ja que coneixem la sintaxi per definir el tipus d’enumeració, vegem un exemple:
enumerror{
IO_ERROR,
DISK_ERROR,
ERROR DE CONNEXIÓ
};
La paraula clau enum sempre s’ha d’utilitzar per definir el tipus d’enumeració. Per tant, sempre que vulgueu definir un tipus d’enumeració, heu d’utilitzar la paraula clau enum abans. Després de la paraula clau enum, heu d'utilitzar un identificador vàlid per definir el fitxer.
A l'exemple anterior, el compilador assignarà IO_ERROR al valor integral: 0, DISK_ERROR al valor integral: 1 i NETWORK_ERROR al valor integral: 2. Per defecte, al primer element enum sempre se li assigna el valor 0, al següent a enum-element se li assigna el valor 1, etc.
Aquest comportament per defecte es pot canviar si cal assignant explícitament el valor integral constant, de la manera següent:
enumerror{IO_ERROR= 2,
DISK_ERROR,
ERROR DE CONNEXIÓ= 8 ,
PRINT_ERROR
};
En aquest cas, el programador assigna explícitament IO_ERROR a un valor de 2, el compilador assigna DISK_ERROR a un valor de 3, el programador assigna explícitament NETWORK_ERROR al valor 8 i PRINT_ERROR s’assigna al següent valor integral de l'element enum anterior NETWORK_ERROR (és a dir, 9) pel compilador.
Per tant, ara enteneu com definir un tipus d’enumeració definit per l’usuari a C. És possible declarar una variable de tipus enum (ja que podem declarar una variable de tipus enter)? Sí, ho és! Podeu declarar la variable enum de la següent manera:
enumerror Hw_Error;De nou, enum és la paraula clau aquí, Error és el tipus enum i Hw_Error és una variable enum.
Ara veurem els exemples següents per comprendre els diversos usos de enum:
- Exemple 1: ús de la definició d'enum per defecte
- Exemple 2: ús de definició d'enum personalitzat
- Exemple 3: definició d'enum mitjançant expressió constant
- Exemple 4: abast d'enum
Exemple 1: ús per defecte de la definició de l’enumeració
En aquest exemple, aprendreu a definir el tipus d’enumeració amb valors constants per defecte. El compilador s'encarregarà d'assignar els valors per defecte als elements enum. A continuació, veureu l'exemple de programa i la sortida corresponent.
#incloure/ * Definiu el tipus d'enum * /
enumerror{
IO_ERROR,
DISK_ERROR,
ERROR DE CONNEXIÓ
};
intprincipal()
{
enumerror Hw_Error; / * Creació de la variable enum * /
printf ('Configurant Hw_Error a IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a NETWORK_ERROR n');
Hw_Error=ERROR DE CONNEXIÓ;
printf ('Valor de Hw_Error =% d n',Hw_Error);
tornar 0;
}
Exemple 2: ús de la definició d’enum personalitzat
En aquest exemple, aprendreu a definir el tipus d’enumeració amb un valor de costum personalitzat. A més, aquest exemple us ajudarà a entendre com es pot fer la inicialització de constants personalitzades en qualsevol ordre aleatori. En aquest exemple, hem definit explícitament el valor constant de l’1ci 3rdelements enum (és a dir, IO_ERROR i NETWORK_ERROR, respectivament), però hem saltat la inicialització explícita per a la 2ndi 4thelements. Ara és responsabilitat del compilador assignar els valors per defecte al 2ndi 4thelements enum (és a dir, DISK_ERROR i PRINT_ERROR, respectivament). DISK_ERROR s'assignarà a un valor de 3 i PRINT_ERROR s'assignarà a un valor de 9. A continuació, veureu l'exemple de programa i la sortida.
#incloure/ * Definiu el tipus d'enum: inicialització personalitzada * /
enumerror{
IO_ERROR= 2,
DISK_ERROR,
ERROR DE CONNEXIÓ= 8,
PRINT_ERROR
};
intprincipal()
{
/ * Declara variable enum * /
enumerror Hw_Error;
printf ('Configurant Hw_Error a IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a NETWORK_ERROR n');
Hw_Error=ERROR DE CONNEXIÓ;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
tornar 0;
}
Exemple 3: definició d'enum mitjançant expressió constant
En aquest exemple, aprendreu a utilitzar l'expressió constant per definir el valor constant dels elements enum.
#incloure/ * Definiu el tipus enum: inicialització personalitzada mitjançant expressió constant
aquí s’utilitza l’expressió constant en cas de:
a. IO_ERROR i
b. ERROR DE CONNEXIÓ
Aquesta és una forma inusual de definir els elements enum; no obstant això, això
programa demostra que aquesta manera d'inicialització dels elements enum és possible a c.
* /
enumerror{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
ERROR DE CONNEXIÓ= 2 == 2,
PRINT_ERROR
};
intprincipal()
{
/ * Declara variable enum * /
enumerror Hw_Error;
printf ('Configurant Hw_Error a IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a NETWORK_ERROR n');
Hw_Error=ERROR DE CONNEXIÓ;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
tornar 0;
}
Exemple 4: enum Abast
En aquest exemple, aprendreu com funciona la regla d'abast per a enum. Es podria haver utilitzat un MACRO (#define) per definir una constant en lloc de l'enum, però la regla d'abast no funciona per a MACRO.
#incloureintprincipal()
{
/ * Definiu el tipus d'enum * /
enumError_1{
IO_ERROR= 10,
DISK_ERROR,
ERROR DE CONNEXIÓ= 3,
PRINT_ERROR
};
{
/ * Definiu el tipus d'enum a l'abast intern * /
enumError_1{
IO_ERROR= 20,
DISK_ERROR,
ERROR DE CONNEXIÓ= 35,
PRINT_ERROR
};
/ * Declara variable enum * /
enumError_1 Hw_Error;
printf ('Configurant Hw_Error a IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a NETWORK_ERROR n');
Hw_Error=ERROR DE CONNEXIÓ;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nConfigurant Hw_Error a PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
}
tornar 0;
}
Comparació entre enum i macro
| Enum | macro |
| La regla d'abast és aplicable per a enum. | La regla d'abast no s'aplica a Macro. |
| L'assignació de valor per defecte Enum es fa automàticament. Enum és molt útil per definir un gran nombre de constants. El compilador pren la inicialització del valor constant per defecte. | El programador sempre ha de mencionar explícitament els valors de les constants de macro. Aquest podria ser un procés tediós per a un gran nombre de constants, ja que el programador sempre ha de definir manualment cada valor constant mentre defineix la macro. |
Conclusió
El programa enum en C es podria considerar un mètode opcional per a programes independents o projectes de mida petita, ja que els programadors sempre poden utilitzar macro en lloc d’un enum. No obstant això, els programadors experimentats solen utilitzar enum sobre macro per a projectes de desenvolupament de programari a gran escala. Això ajuda a escriure programes nets i llegibles.