Dichiarazioni di enumerazioni C

Un'enumerazione è un set di costanti di tipo 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 enum possono essere utilizzate nelle espressioni di indicizzazione e come operandi di tutti gli operatori aritmetici e relazionali. Le enumerazioni forniscono un'alternativa alla direttiva per il preprocessore #define con il vantaggio che i valori possono essere generati automaticamente e sono conformi alle 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. Una costante di enumerazione o un valore di tipo enumerato può essere utilizzato ovunque il linguaggio C consenta un'espressione Integer.

Sintassi

enum-specifier:
 enumidentifier_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 è spesso definito il "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 trovarsi nell'ambito corrente. Poiché il tipo di enumerazione è definito altrove, l'oggetto enumerator-list non viene visualizzato in questa dichiarazione. Le dichiarazioni dei tipi derivati da enumerazioni e da dichiarazioni typedef per i tipi di enumerazione possono utilizzare il tag di enumerazione prima che sia 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 vengono applicate 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 sono conformi alle normali regole di ambito. Devono essere differenti da altri tag di enumerazione, struttura e unione con la stessa visibilità.

Esempi

In questi esempi vengono illustrate 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 a saturday per impostazione predefinita. L'identificatore sunday è impostato in modo esplicito su 0. Agli identificatori restanti vengono forniti 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 tipo di enumerazione DAY era dichiarato in precedenza, è necessario solo il tag DAY di enumerazione.

Per assegnare in modo esplicito un Integer a una variabile di un tipo di dati enumerato, utilizzare 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 come

enum BOOLEAN { false, true } end_flag, match_flag;

o come

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

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

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

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

enum { yes, no } response;

Vedi anche

Enumerazioni