Come usare enum in c lingua

Come usare enum in c lingua
Il programma Enum nel linguaggio di programmazione C viene utilizzato per definire i valori costanti integrali, il che è molto utile per scrivere programmi puliti e leggibili. I programmatori normalmente usano l'enumerazione per definire le costanti integrali denominate nei loro programmi per fornire una migliore leggibilità e manutenibilità del software. Questo articolo discuterà in dettaglio Enum.

Sintassi

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).

Immersione profonda in enum

Ora, dal momento che conosciamo la sintassi per definire il tipo di enumerazione, guardiamo un esempio:

Errore enum
Io_error,
Disk_error,
ERRORE DI RETE
;

La parola chiave "enum" deve sempre essere utilizzata per definire il tipo di enumerazione. Quindi, ogni volta che si desidera definire un tipo di enumerazione, è necessario utilizzare la parola chiave "enum" prima . 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, il prossimo 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 enum
Io_error = 2,
Disk_error,
Network_error = 8 ,
Print_error
;

In questo caso, IO_ERROR è esplicitamente assegnato a un valore di 2 dal programmatore, Disk_error è assegnato a un valore di 3 dal compilatore, Network_error viene esplicitamente assegnato al valore di 8 dal programmatore e Print_error viene assegnato al successivo Valore integrale del precedente elemento enum 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 (poiché possiamo dichiarare una variabile di tipo intero)? Sì! È possibile dichiarare la variabile Enum come segue:

Errore enum hw_error;

Ancora una volta, "enum" è la parola chiave qui, "errore" è il tipo enum e "hw_error" è una variabile Enum.

Esamineremo ora 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 enum usando espressione costante
  • Esempio 4: ENUM AMPOPE

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à dell'assegnazione dei valori predefiniti agli elementi enum. Di seguito, vedrai il programma di esempio e l'output corrispondente.

#includere
/ * Definire il tipo enum */
Errore enum
Io_error,
Disk_error,
ERRORE DI RETE
;
int main ()

Errore enum hw_error; /* Creazione della variabile enum*/
printf ("Impostazione hw_error su io_error \ n");
Hw_error = io_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su disk_error \ n");
Hw_error = disk_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su network_error \ n");
Hw_error = network_error;
printf ("Valore di hw_error = %d \ n", hw_error);
restituzione 0;

Esempio 2: Utilizzo della definizione enum 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 fatta in qualsiasi ordine casuale. In questo esempio, abbiamo definito esplicitamente il valore costante per il 1st e 3Rd enum elements (i.e., Io_error e network_error, rispettivamente), ma abbiamo saltato l'inizializzazione esplicita per il 2nd e 4th elementi. Ora è responsabilità del compilatore assegnare i valori predefiniti al 2nd e 4th enum elements (i.e., Disk_error e print_error, rispettivamente). Disk_error verrà assegnato a un valore di 3 e print_error verrà assegnato a un valore di 9. Di seguito, vedrai il programma di esempio e l'output.

#includere
/* Definire il tipo ENUM - Inizializzazione personalizzata*/
Errore enum
Io_error = 2,
Disk_error,
Network_error = 8,
Print_error
;
int main ()

/* Dichiara la variabile enum*/
Errore enum hw_error;
printf ("Impostazione hw_error su io_error \ n");
Hw_error = io_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su disk_error \ n");
Hw_error = disk_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su network_error \ n");
Hw_error = network_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su print_error \ n");
Hw_error = print_error;
printf ("Valore di hw_error = %d \ n", hw_error);
restituzione 0;

Esempio 3: Definizione enum usando espressione costante

In questo esempio, imparerai come usare l'espressione costante per definire il valore costante per gli elementi enum.

#includere
/* Definire il tipo ENUM - Inizializzazione personalizzata mediante espressione costante
L'espressione costante viene utilizzata qui in 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 per l'inizializzazione di ENUM è possibile in C.
*/
Errore enum
Io_error = 1 + 2 * 3 + 4,
Disk_error,
Network_error = 2 == 2,
Print_error
;
int main ()

/* Dichiara la variabile enum*/
Errore enum hw_error;
printf ("Impostazione hw_error su io_error \ n");
Hw_error = io_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su disk_error \ n");
Hw_error = disk_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su network_error \ n");
Hw_error = network_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su print_error \ n");
Hw_error = print_error;
printf ("Valore di hw_error = %d \ n", hw_error);
restituzione 0;

Esempio 4: ENUM AMPOPE

In questo esempio, imparerai come funziona la regola di scoping per enum. Una macro (#define) avrebbe potuto essere usata per definire una costante anziché l'enum, ma la regola di scoping non funziona per la macro.

#includere
int main ()

/ * Definire il tipo enum */
enum error_1
Io_error = 10,
Disk_error,
Network_error = 3,
Print_error
;

/* Definire il tipo enum nell'ambito interno*/
enum error_1
Io_error = 20,
Disk_error,
Network_error = 35,
Print_error
;
/* Dichiara la 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 ("\ nsetting hw_error su disk_error \ n");
Hw_error = disk_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su network_error \ n");
Hw_error = network_error;
printf ("Valore di hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error su print_error \ n");
Hw_error = print_error;
printf ("Valore di hw_error = %d \ n", hw_error);

restituzione 0;

Confronto tra enum e macro

Enum Macro
La regola di scoping è applicabile per enum. La regola di scoping non è applicabile per la macro.
L'assegnazione del valore enum predefinito avviene automaticamente.

Enum è molto utile per definire un gran numero di costanti. Il compilatore prende l'inizializzazione del valore costante predefinito.

I valori 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 autonomi o progetti di piccole dimensioni poiché i programmatori possono sempre usare la macro anziché un enum. Tuttavia, i programmatori esperti tendono a utilizzare ENUM sulla macro per progetti di sviluppo software su larga scala. Questo aiuta a scrivere programmi puliti e leggibili.