Déclarations d’énumération C

Une énumération se compose d'un ensemble de constantes entières nommées. Une déclaration de type d’énumération donne le nom de la balise d’énumération (facultative). Et elle définit l’ensemble d’identificateurs entiers nommés (appelé ensemble d’énumération, constantes d’énumérateur, énumérateurs ou membres). Une variable du type énumération stocke une des valeurs de l'ensemble d'énumération défini par ce type.

Les variables de type enum peuvent être utilisées dans des expressions d'indexation et comme opérandes de tous les opérateurs arithmétiques et relationnels. Les énumérations offrent une alternative à la directive de préprocesseur #define et présentent l'avantage suivant : les valeurs peuvent être générées pour vous et se conformer aux règles normales de portée.

En C ANSI, les expressions qui définissent la valeur d’une constante d’énumérateur ont toujours le type int. Cela signifie que le stockage associé à une variable d’énumération est le stockage requis pour une valeur int unique. Une constante d'énumération ou une valeur de type énuméré peut être utilisée partout où le langage C autorise une expression d'entier.

Syntaxe

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

enumerator-list:
 enumerator
 enumerator-list , enumerator

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

enumeration-constant:
 identifier

Le identifier facultatif nomme le type d’énumération défini par enumerator-list. Cet identificateur est souvent appelé « étiquette » de l’énumération spécifiée par la liste. Un spécificateur de type déclare identifier comme la balise de l’énumération spécifiée par l’enumerator-list non terminal, comme indiqué ici :

enum identifier
{
    // enumerator-list
}

enumerator-list définit les membres de l’ensemble d’énumération.

Si la déclaration d’une étiquette est visible, les déclarations ultérieures qui utilisent l’étiquette mais omettent l’élément enumerator-list spécifient le type énuméré déclaré précédemment. L’étiquette doit faire référence à un type énumération défini, et ce type énumération doit se trouver dans la portée actuelle. Étant donné que le type d’énumération est défini ailleurs, l’élément enumerator-list n’apparaît pas dans cette déclaration. Les déclarations des types dérivés à partir des énumérations et les déclarations de typedef pour les types énumération peuvent utiliser la balise d'énumération avant que le type énumération ne soit défini.

Chaque enumeration-constant dans un enumerator-list nomme une valeur de l’ensemble d’énumération. Par défaut, la première enumeration-constant est associée à la valeur 0. La enumeration-constant suivante dans la liste est associée à la valeur (constant-expression + 1), sauf si vous l’associez explicitement à une autre valeur. Le nom d’une enumeration-constant est équivalent à sa valeur.

Vous pouvez utiliser enumeration-constant = constant-expression pour remplacer la séquence de valeurs par défaut. Autrement dit, s’il enumeration-constant = constant-expression apparaît dans la enumerator-list, la enumeration-constant est associée à la valeur donnée par constant-expression. La constant-expression doit avoir le type int et ne peut pas être négative.

Les règles suivantes s'appliquent aux membres d'un ensemble d'énumération :

• Un ensemble d'énumération peut contenir des valeurs de constante en double. Par exemple, vous pouvez associer la valeur 0 à deux identificateurs différents, par exemple, nommés null et zero, dans le même ensemble.

• Les identificateurs dans la liste d'énumérations doivent être distincts des autres identificateurs dans la même portée ayant la même visibilité. Cela inclut les noms de variable et identificateurs ordinaires dans les autres listes d'énumération.

• Les balises d'énumération obéissent aux règles normales de portée. Elles doivent être distinctes des autres balises d'énumération, de structure et d'union ayant la même visibilité.

Exemples

Les exemples suivants illustrent des déclarations d'énumération :

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;

La valeur 0 est associée à saturday par défaut. L'identificateur sunday est explicitement défini à 0. Les autres identificateurs sont définis avec les valeurs 1 à 5 par défaut.

Dans cet exemple, une valeur de l'ensemble DAY est assignée à la variable today.

enum DAY today = wednesday;

Le nom de la constante d'énumération est utilisé pour assigner la valeur. Étant donné que le type énumération DAY a été déclaré précédemment, seule la balise d'énumération DAY est nécessaire.

Pour assigner explicitement une valeur d'entier à une variable d'un type de données énuméré, utilisez un cast de type :

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

Ce cast est recommandé en C mais n'est pas requis.

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 */

Cette déclaration peut également être spécifiée sous la forme

enum BOOLEAN { false, true } end_flag, match_flag;

ou sous la forme

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

Voici un exemple qui utilise ces variables :

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

Les types de données d'énumérateur sans nom peuvent également être déclarés. Le nom du type de données est omis, mais les variables peuvent être déclarées. La variable response est une variable du type défini :

enum { yes, no } response;

Voir aussi

Énumérations