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 définit l’ensemble d’identificateurs entiers nommés (appelé jeu d’énumération, constantes d’énumération, énumérateurs, énumérateurs ou membres). Une variable du type d’énumération stocke l’une des valeurs du jeu d’énumération défini par ce type.

Les variables de enum type peuvent être utilisées dans les expressions d’indexation et en tant qu’opérandes de tous les opérateurs arithmétiques et relationnels. Les énumérations offrent une alternative à la #define directive de préprocesseur avec les avantages que les valeurs peuvent être générées pour vous et obéissent aux règles d’étendue normales.

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

Syntaxe

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

enumerator-list :
 enumerator
  enumerator-list , enumerator

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

enumeration-constant :
 identifier

Noms facultatifs identifier du type d’énumération défini par enumerator-list. Cet identificateur est souvent appelé « balise » de l’énumération spécifiée par la liste. Un spécificateur de type déclare identifier être la balise de l’énumération spécifiée par l’énumération enumerator-list non déterministe, comme indiqué ici :

enum identifier
{
    // enumerator-list
}

Définit enumerator-list les membres du jeu d’énumérations.

Si la déclaration d’une balise est visible, les déclarations ultérieures qui utilisent la balise, mais omettent de enumerator-list spécifier le type énuméré précédemment déclaré. La balise doit faire référence à un type d’énumération défini et ce type d’énumération doit être dans l’étendue actuelle. Étant donné que le type d’énumération est défini ailleurs, il enumerator-list n’apparaît pas dans cette déclaration. Les déclarations de types dérivés d’énumérations et typedef de déclarations pour les types d’énumération peuvent utiliser la balise d’énumération avant la définition du type d’énumération.

Chacun enumeration-constant dans un enumerator-list nom une valeur du jeu d’énumération. Par défaut, le premier enumeration-constant est associé à la valeur 0. La suivante enumeration-constant de la liste est associée à la valeur ( constant-expression + 1), sauf si vous l’associez explicitement à une autre valeur. Le nom d’un 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 apparaît dans le enumerator-list, il enumeration-constant est associé à la valeur donnée par constant-expression.enumeration-constant = constant-expression Le constant-expression type doit int être négatif.

Les règles suivantes s’appliquent aux membres d’un jeu d’énumération :

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

• Les identificateurs de la liste d’énumération doivent être distincts d’autres identificateurs dans la même étendue avec la même visibilité. Cela inclut des noms et des identificateurs de variables ordinaires dans d’autres listes d’énumération.

• Les balises d’énumération obéissent aux règles d’étendue normales. Elles doivent être distinctes d’autres étiquettes d’énumération, de structure et d’union avec la même visibilité.

Exemples

Ces exemples illustrent les 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 défini explicitement sur 0. Les identificateurs restants reçoivent les valeurs 1 à 5 par défaut.

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

enum DAY today = wednesday;

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

Pour affecter explicitement une valeur entière à 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 obligatoire.

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 en tant que

enum BOOLEAN { false, true } end_flag, match_flag;

ou en tant que

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

Un exemple qui utilise ces variables peut ressembler à ceci :

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

Les types de données d’énumérateur non nommés 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 est une variable response du type défini :

enum { yes, no } response;

Voir aussi

Énumérations(C++)