Dichiarazioni di enumerazione C

Un'enumerazione è costituita da un set di costanti integer denominate. Una dichiarazione di tipo di enumerazione assegna il nome del tag di enumerazione (facoltativo). Definisce inoltre il set di identificatori integer denominati (denominati set di enumerazioni, costanti enumeratori, enumeratori o membri). Una variabile del tipo di enumerazione archivia uno dei valori del set di enumerazione definito da tale tipo.

Le variabili di tipo possono essere usate nelle espressioni di enum indicizzazione e come operandi di tutti gli operatori aritmetici e relazionali. Le enumerazioni offrono un'alternativa alla direttiva del #define preprocessore con i vantaggi che è possibile generare i valori e rispettare le normali regole di ambito.

In ANSI C le espressioni che definiscono il valore di una costante enumeratore hanno int sempre un tipo. Ciò significa che lo spazio di archiviazione associato a una variabile di enumerazione è l'archiviazione necessaria per un singolo int valore. È possibile usare una costante di enumerazione o un valore di tipo enumerato in qualsiasi punto del linguaggio C che consenta un'espressione integer.

Sintassi

enum-specifier:
  enum identifier _optare{enumerator-list}
  enum identifier

enumerator-list:
 enumerator
  enumerator-list , enumerator

enumerator:
 enumeration-constant
  enumeration-constant = constant-expression

enumeration-constant:
 identifier

Il nome facoltativo identifier del tipo di enumerazione definito da enumerator-list. Questo identificatore viene spesso definito "tag" dell'enumerazione specificata dall'elenco. Un identificatore di tipo dichiara identifier di essere il tag dell'enumerazione specificata dal enumerator-list non determiniale, come illustrato di seguito:

enum identifier
{
    // enumerator-list
}

enumerator-list Definisce i membri del set di enumerazione.

Se la dichiarazione di un tag è visibile, le dichiarazioni successive che usano il tag ma omettono enumerator-list specificano il tipo enumerato dichiarato in precedenza. Il tag deve fare riferimento a un tipo di enumerazione definito e tale tipo di enumerazione deve essere nell'ambito corrente. Poiché il tipo di enumerazione è definito altrove, l'oggetto enumerator-list non viene visualizzato in questa dichiarazione. Le dichiarazioni di tipi derivati da enumerazioni e typedef dichiarazioni per i tipi di enumerazione possono utilizzare il tag di enumerazione prima che venga definito il tipo di enumerazione.

Ognuno enumeration-constant di essi enumerator-list assegna un nome a un valore del set di enumerazione. Per impostazione predefinita, il primo enumeration-constant è associato al valore 0. Il successivo enumeration-constant nell'elenco è associato al valore di ( constant-expression + 1 ), a meno che non venga associato in modo esplicito a un altro valore. Il nome di un oggetto enumeration-constant equivale al relativo valore.

È possibile usare enumeration-constant = constant-expression per eseguire l'override della sequenza predefinita di valori. Ovvero, se enumeration-constant = constant-expression viene visualizzato in , l'oggetto enumerator-listenumeration-constant è associato al valore specificato da .constant-expression Deve constant-expression avere int un tipo e può essere negativo.

Le regole seguenti si applicano ai membri di un set di enumerazione:

• Un set di enumerazione può contenere valori costanti duplicati. Ad esempio, è possibile associare il valore 0 a due identificatori diversi, ad esempio i membri denominati null e zero, nello stesso set.

• Gli identificatori nell'elenco di enumerazione devono essere distinti da altri identificatori nello stesso ambito con la stessa visibilità. Che include nomi e identificatori di variabili ordinari in altri elenchi di enumerazione.

• I tag di enumerazione rispettano le normali regole di ambito. Devono essere distinti da altri tag di enumerazione, struttura e unione con la stessa visibilità.

Esempi

Questi esempi illustrano le dichiarazioni di enumerazione:

enum DAY            /* Defines an enumeration type    */
{
    saturday,       /* Names day and declares a       */
    sunday = 0,     /* variable named workday with    */
    monday,         /* that type                      */
    tuesday,
    wednesday,      /* wednesday is associated with 3 */
    thursday,
    friday
} workday;

Il valore 0 è associato per saturday impostazione predefinita. L'identificatore viene impostato in modo esplicito sunday su 0. Agli identificatori rimanenti vengono assegnati i valori da 1 a 5 per impostazione predefinita.

In questo esempio un valore del set DAY viene assegnato alla variabile today.

enum DAY today = wednesday;

Il nome della costante di enumerazione viene utilizzato per assegnare il valore. Poiché il DAY tipo di enumerazione è stato dichiarato in precedenza, è necessario solo il tag DAY di enumerazione.

Per assegnare in modo esplicito un valore intero a una variabile di un tipo di dati enumerato, usare un cast di tipo:

workday = ( enum DAY ) ( day_value - 1 );

Questo cast è consigliato in C, ma non è obbligatorio.

enum BOOLEAN  /* Declares an enumeration data type called BOOLEAN */
{
    false,     /* false = 0, true = 1 */
    true
};

enum BOOLEAN end_flag, match_flag; /* Two variables of type BOOLEAN */

Questa dichiarazione può essere specificata anche come

enum BOOLEAN { false, true } end_flag, match_flag;

o come

enum BOOLEAN { false, true } end_flag;
enum BOOLEAN match_flag;

Un esempio che usa queste variabili potrebbe essere simile al seguente:

if ( match_flag == false )
    {
     .
     .   /* statement */
     .
    }
    end_flag = true;

È anche possibile dichiarare i tipi di dati dell'enumeratore senza nome. Il nome del tipo di dati viene omesso, ma le variabili possono essere dichiarate. La variabile è una variabile response del tipo definito:

enum { yes, no } response;

Vedere anche

Enumerazioni (C++)