Phenquestions
Sintassi
enumEnumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
… ,
Enumeration_Constant_Element-n,
;
Il valore predefinito di Enumeration_Constant_Element-1 è 0, il valore di Enumeration_Constant_Element-2 è 1, il valore di Enumeration_Constant_Element-3 è 2 e il valore di Enumeration_Constant_Element-n è (n-1).
Immergiti in profondità in Enum
Ora, poiché conosciamo la sintassi per definire il tipo di enumerazione, esaminiamo un esempio:
errore enumIO_ERROR,
DISK_ERROR,
ERRORE DI RETE
;
La parola chiave "enum" deve essere sempre utilizzata per definire il tipo di enumerazione. Quindi, ogni volta che si desidera definire un tipo di enumerazione, è necessario utilizzare prima la parola chiave "enum"
Nell'esempio sopra, il compilatore assegnerà IO_ERROR al valore integrale: 0, DISK_ERROR al valore integrale: 1 e NETWORK_ERROR al valore integrale: 2. Per impostazione predefinita, al primo elemento enum viene sempre assegnato il valore 0, al successivo elemento enum viene assegnato il valore 1 e così via.
Questo comportamento predefinito può essere modificato se necessario assegnando esplicitamente il valore integrale costante, come segue:
errore enumIO_ERROR = 2,
DISK_ERROR,
ERRORE_RETE = 8 ,
PRINT_ERROR
;
In questo caso, IO_ERROR è assegnato esplicitamente al valore 2 dal programmatore, DISK_ERROR è assegnato al valore 3 dal compilatore, NETWORK_ERROR è assegnato esplicitamente al valore 8 dal programmatore e PRINT_ERROR è assegnato al successivo valore integrale dell'elemento enum precedente NETWORK_ERROR (i.e., 9) dal compilatore.
Quindi, ora capisci come definire un tipo di enumerazione definito dall'utente in C. È possibile dichiarare una variabile di tipo enum (come possiamo dichiarare una variabile di tipo intero)? Sì! Puoi dichiarare la variabile enum come segue:
enum Errore Hw_Error;Ancora una volta, "enum" è la parola chiave qui, "Error" è il tipo enum e "Hw_Error" è una variabile enum.
Ora esamineremo i seguenti esempi per comprendere i vari usi di enum:
- Esempio 1: utilizzo della definizione enum predefinita
- Esempio 2: utilizzo della definizione enum personalizzata
- Esempio 3: definizione di enum usando l'espressione costante
- Esempio 4: ambito enum
Esempio 1: utilizzo della definizione enum predefinita
In questo esempio imparerai come definire il tipo di enumerazione con valori costanti predefiniti. Il compilatore si occuperà di assegnare i valori predefiniti agli elementi enum. Di seguito, vedrai il programma di esempio e l'output corrispondente.
#includere/* Definisce il tipo enum */
errore enum
IO_ERROR,
DISK_ERROR,
ERRORE DI RETE
;
intero principale()
enum Errore Hw_Error; /* Creazione variabile enum*/
printf("Impostazione Hw_Error su IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
restituisce 0;
Esempio 2: utilizzo della definizione di enumerazione personalizzata
In questo esempio imparerai come definire il tipo di enumerazione con un valore costante personalizzato. Inoltre, questo esempio ti aiuterà a capire come l'inizializzazione delle costanti personalizzate può essere eseguita in qualsiasi ordine casuale. In questo esempio, abbiamo definito esplicitamente il valore costante per 1sto e 3rd enum elementi (i.e., IO_ERROR e NETWORK_ERROR, rispettivamente), ma abbiamo saltato l'inizializzazione esplicita per il 2nd e 4questo elementi. Ora è responsabilità del compilatore assegnare i valori di default al 2nd e 4questo enum elementi (i.e., DISK_ERROR e PRINT_ERROR, rispettivamente). DISK_ERROR verrà assegnato al valore 3 e PRINT_ERROR verrà assegnato al valore 9. Di seguito, vedrai il programma di esempio e l'output.
#includere/* Definisce il tipo enum - Inizializzazione personalizzata*/
errore enum
IO_ERROR = 2,
DISK_ERROR,
ERRORE_RETE = 8,
PRINT_ERROR
;
intero principale()
/* Dichiara variabile enum*/
enum Errore Hw_Error;
printf("Impostazione Hw_Error su IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
restituisce 0;
Esempio 3: definizione di enum utilizzando l'espressione costante
In questo esempio imparerai come usare l'espressione costante per definire il valore costante per gli elementi enum.
#includere/* Definisce il tipo enum - inizializzazione personalizzata usando l'espressione costante
l'espressione costante viene utilizzata qui nel caso di:
un. IO_ERROR e
b. ERRORE DI RETE
Questo è un modo insolito di definire gli elementi enum; tuttavia, questo
il programma dimostra che questo modo di inizializzare gli elementi enum è possibile in c.
*/
errore enum
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
ERRORE_RETE = 2 == 2,
PRINT_ERROR
;
intero principale()
/* Dichiara variabile enum*/
enum Errore Hw_Error;
printf("Impostazione Hw_Error su IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
restituisce 0;
Esempio 4: enum Scope
In questo esempio imparerai come funziona la regola di ambito per enum. Una MACRO (#define) avrebbe potuto essere utilizzata per definire una costante invece dell'enum, ma la regola di ambito non funziona per MACRO.
#includereintero principale()
/* Definisce il tipo enum */
enum Errore_1
IO_ERROR = 10,
DISK_ERROR,
ERRORE_RETE = 3,
PRINT_ERROR
;
/* Definisce il tipo enum nell'ambito interno*/
enum Errore_1
IO_ERROR = 20,
DISK_ERROR,
ERRORE_RETE = 35,
PRINT_ERROR
;
/* Dichiara variabile enum*/
enum Error_1 Hw_Error;
printf("Impostazione Hw_Error su IO_ERROR\n");
Hw_Error = IO_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su DISK_ERROR\n");
Hw_Error = DISK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su NETWORK_ERROR\n");
Hw_Error = NETWORK_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
printf("\nImpostazione Hw_Error su PRINT_ERROR\n");
Hw_Error = PRINT_ERROR;
printf("Valore di Hw_Error = %d \n",Hw_Error);
restituisce 0;
Confronto tra enum e macro
| Enum | macro |
| La regola di ambito è applicabile per enum. | La regola di ambito non è applicabile per Macro. |
| L'assegnazione del valore Enum predefinito avviene automaticamente. Enum è molto utile per definire un gran numero di costanti. Il compilatore accetta l'inizializzazione del valore costante predefinito. | I valori delle macro costanti devono sempre essere menzionati esplicitamente dal programmatore. Questo potrebbe essere un processo noioso per un gran numero di costanti poiché il programmatore deve sempre definire manualmente ogni valore costante durante la definizione della Macro. |
Conclusione
Il programma enum in C potrebbe essere considerato un metodo opzionale per programmi standalone o progetti di piccole dimensioni poiché i programmatori possono sempre utilizzare macro invece di un enum. Tuttavia, i programmatori esperti tendono a utilizzare enum su macro per progetti di sviluppo software su larga scala. Questo aiuta a scrivere programmi puliti e leggibili.
