Enumerations

Un type énuméré est un type distinct dont la valeur est une valeur de son type sous-jacent (voir ci-dessous), qui inclut les valeurs des constantes explicitement nommées ( constantes d'énumération ).

Syntaxe

Le type énuméré est déclaré en utilisant le spécificateur d'énumération suivant comme type-specifier dans la grammaire de déclaration :

où enumerator-list est une liste séparée par des virgules (avec virgule finale autorisée) (depuis C99) de enumerator , chacun ayant la forme :

où

Comme avec struct ou union , une déclaration qui introduit un type énuméré et une ou plusieurs constantes d'énumération peut également déclarer un ou plusieurs objets de ce type ou de type dérivé de celui-ci.

enum color { RED, GREEN, BLUE } c = RED, *cp = &c;
// introduit le type enum color
// les constantes entières RED, GREEN, BLUE
// l'objet c de type enum color
// l'objet cp de type pointeur vers enum color

Explication

Chaque constante d'énumération qui apparaît dans le corps d'un spécificateur d'énumération devient une constante entière avec le type int (jusqu'en C23) dans la portée englobante et peut être utilisée partout où des constantes entières sont requises (par exemple comme étiquette de cas ou comme taille de tableau non-VLA).

enum color { RED, GREEN, BLUE } r = RED;
switch(r)
{
case RED:
    puts("rouge");
    break;
case GREEN:
    puts("vert");
    break;
case BLUE:
    puts("bleu");
    break;
}

Si enumeration-constant est suivi de = constant-expression , sa valeur est celle de cette expression constante. Si enumeration-constant n'est pas suivi de = constant-expression , sa valeur est la valeur immédiatement supérieure à celle de l'énumérateur précédent dans la même énumération. La valeur du premier énumérateur (s'il n'utilise pas = constant-expression ) est zéro.

enum Foo { A, B, C = 10, D, E = 1, F, G = F + C };
// A=0, B=1, C=10, D=11, E=1, F=2, G=12

L' identifiant lui-même, s'il est utilisé, devient le nom du type énuméré dans l'espace de noms des balises name space et nécessite l'utilisation du mot-clé enum (sauf s'il est typedef dans l'espace de noms ordinaire).

enum color { RED, GREEN, BLUE };
enum color r = RED; // OK
// color x = GREEN; // Erreur : color n'est pas dans l'espace de noms ordinaire
typedef enum color color_t;
color_t x = GREEN; // OK

Chaque type énuméré sans type sous-jacent fixe (depuis C23) est compatible avec l'un des : char , un type entier signé, ou un type entier non signé (à l'exclusion de bool et des types entiers à précision de bits) (depuis C23) . Le type compatible avec un type énuméré donné est défini par l'implémentation, mais quel qu'il soit, il doit être capable de représenter toutes les valeurs des énumérateurs de cette énumération. Pour toutes les énumérations avec un type sous-jacent fixe, le type énuméré est compatible avec le type sous-jacent de l'énumération. (depuis C23)

Les types énumérés sont des types entiers, et en tant que tels peuvent être utilisés partout où d'autres types entiers le peuvent, y compris dans les conversions implicites et les opérateurs arithmétiques .

enum { ONE = 1, TWO } e;
long n = ONE; // promotion
double d = ONE; // conversion
e = 1.2; // conversion, e is now ONE
e = e + 1; // e is now TWO

Notes

Contrairement aux struct ou aux union , il n'existe pas d'enums déclarés d'avance en C :

enum Color; // Erreur : pas de déclarations anticipées pour les énumérations en C
enum Color { RED, GREEN, BLUE };

Les énumérations permettent la déclaration de constantes nommées d'une manière plus pratique et structurée que ne le fait #define ; elles sont visibles dans le débogueur, respectent les règles de portée et participent au système de types.

#define TEN 10
struct S { int x : TEN; }; // Correct

ou

enum { TEN = 10 };
struct S { int x : TEN; }; // également valide

Depuis C23 constexpr peut être utilisé dans le même but :

constexpr int TEN = 10;
struct S { int x : TEN; }; // également valide

De plus, comme une struct ou une union n'établit pas sa portée en C, un type énumération et ses constantes d'énumération peuvent être introduits dans la spécification des membres de la première, et leur portée est la même que celle de la première, par la suite.

struct Element
{
    int z;
    enum State { SOLID, LIQUID, GAS, PLASMA } state;
} oxygen = { 8, GAS };
// le type enum State et ses constantes d'énumération restent visibles ici, par ex.
void foo(void)
{
    enum State e = LIQUID; // OK
    printf("%d %d %d ", e, oxygen.state, PLASMA); // affiche 1 2 3
}

Exemple

#include <stdio.h>
int main(void)
{
    enum TV { FOX = 11, CNN = 25, ESPN = 15, HBO = 22, MAX = 30, NBC = 32 };
    printf("List of cable stations:\n");
    printf(" FOX: \t%2d\n", FOX);
    printf(" HBO: \t%2d\n", HBO);
    printf(" MAX: \t%2d\n", MAX);
}

List of cable stations:
 FOX:   11
 HBO:   22
 MAX:   30

Références

Mots-clés

enum

Voir aussi