Sintassi
enum <Nome tipo enum> {Enumeration_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:
enumErrore{
IO_ERROR,
DISK_ERROR,
ERRORE DI RETE
};
La parola chiave enum deve essere sempre utilizzata per definire il tipo di enumerazione. Pertanto, ogni volta che si desidera definire un tipo di enumerazione, è necessario utilizzare la parola chiave enum prima di . Dopo la parola chiave enum, è necessario utilizzare un identificatore valido per definire il .
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 enum-element viene assegnato il valore 1 e così via.
Questo comportamento predefinito può essere modificato se necessario assegnando esplicitamente il valore integrale costante, come segue:
enumErrore{IO_ERROR= 2,
DISK_ERROR,
ERRORE DI 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 (cioè 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:
enumErrore Hw_Error;Di nuovo, 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 */
enumErrore{
IO_ERROR,
DISK_ERROR,
ERRORE DI RETE
};
intprincipale()
{
enumErrore Hw_Error; /* Creazione variabile enum*/
printf ('Impostazione Hw_Error su IO_ERROR ');
Hw_Error=IO_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su DISK_ERROR ');
Hw_Error=DISK_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su NETWORK_ERROR ');
Hw_Error=ERRORE DI RETE;
printf ('Valore di Hw_Error = %d ',Hw_Error);
Restituzione 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 1nse 3rdenum elementi (cioè, IO_ERROR e NETWORK_ERROR, rispettivamente), ma abbiamo saltato l'inizializzazione esplicita per il 2nse 4nselementi. Ora è responsabilità del compilatore assegnare i valori di default al 2nse 4nsenum elementi (cioè, DISK_ERROR e PRINT_ERROR, rispettivamente). DISK_ERROR sarà assegnato al valore 3 e PRINT_ERROR sarà assegnato al valore 9. Di seguito, vedrai il programma di esempio e l'output.
#includere/* Definisce il tipo enum - Inizializzazione personalizzata*/
enumErrore{
IO_ERROR= 2,
DISK_ERROR,
ERRORE DI RETE= 8,
PRINT_ERROR
};
intprincipale()
{
/* Dichiara variabile enum*/
enumErrore Hw_Error;
printf ('Impostazione Hw_Error su IO_ERROR ');
Hw_Error=IO_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su DISK_ERROR ');
Hw_Error=DISK_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su NETWORK_ERROR ');
Hw_Error=ERRORE DI RETE;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostazione di Hw_Error su PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
Restituzione 0;
}
Esempio 3: definizione di enum usando l'espressione costante
In questo esempio imparerai come utilizzare 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.
* /
enumErrore{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
ERRORE DI RETE= 2 == 2,
PRINT_ERROR
};
intprincipale()
{
/* Dichiara variabile enum*/
enumErrore Hw_Error;
printf ('Impostazione Hw_Error su IO_ERROR ');
Hw_Error=IO_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su DISK_ERROR ');
Hw_Error=DISK_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su NETWORK_ERROR ');
Hw_Error=ERRORE DI RETE;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostazione di Hw_Error su PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
Restituzione 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.
#includereintprincipale()
{
/* Definisce il tipo enum */
enumErrore_1{
IO_ERROR= 10,
DISK_ERROR,
ERRORE DI RETE= 3,
PRINT_ERROR
};
{
/* Definisce il tipo enum nell'ambito interno*/
enumErrore_1{
IO_ERROR= venti,
DISK_ERROR,
ERRORE DI RETE= 35,
PRINT_ERROR
};
/* Dichiara variabile enum*/
enumErrore_1 Hw_Error;
printf ('Impostazione Hw_Error su IO_ERROR ');
Hw_Error=IO_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su DISK_ERROR ');
Hw_Error=DISK_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostare Hw_Error su NETWORK_ERROR ');
Hw_Error=ERRORE DI RETE;
printf ('Valore di Hw_Error = %d ',Hw_Error);
printf (' Impostazione di Hw_Error su PRINT_ERROR ');
Hw_Error=PRINT_ERROR;
printf ('Valore di Hw_Error = %d ',Hw_Error);
}
Restituzione 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 numero elevato 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 di 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.