Enumérations

Remonter à Enumérations - Index

Un type énumération de données permet d'obtenir des identificateurs mnémoniques pour un ensemble de valeurs entières. Par exemple, la déclaration suivante :

enum jours { lun, mar, mer, jeu, ven, sam, dim } touslesjours;

établit un type entier unique, enum jours, une variable de ce type touslesjours et un ensemble d'énumérateurs (dim, lun,...) avec des valeurs entières constantes.

L'option du compilateur -b contrôle l'option "Traiter les Enums comme des Ints". Quand ce commutateur est utilisé, le compilateur alloue un mot entier (un int sur quatre octets) pour les types énumération (variables de type enum). L'option est activée par défaut, ce qui signifie que les enums concernent toujours des int) si l'intervalle des valeurs l'autorise, mais la valeur est toujours transformée en int lorsqu'elle apparaît dans des expressions. Les identificateurs utilisés dans une liste d'énumérateurs sont implicitement du type signed char, unsigned char ou int, selon la valeur de ces énumérateurs. S'il est possible de représenter toutes les valeurs dans un signed ou unsigned char, cela devient le type de chaque énumérateur.

En C, une variable de type énumération peut recevoir n'importe quelle valeur de type int ; aucune vérification n'est effectuée. En C++, une variable de type énumération ne peut recevoir de valeur que de l'un de ses énumérateurs : Ainsi :

anyday = mon;       // OK
anyday = 1;         // illégal, même si lun == 1

L'identificateur jours est le sélecteur facultatif utilisable dans les déclarations suivantes de variables d'énumérations de type enum jours :

enum jours jours_travail, jours_congé; // déclare deux variables

En C++, il est possible d'omettre le mot clé enum si jours ne désigne pas autre chose dans la même portée.

Comme dans les déclarations struct et union, vous pouvez laisser de côté le sélecteur si aucune autre variable de ce type enum n'est nécessaire :

enum jours { dim, lun, mar, mer, jeu, ven, sam } un_jour;
/* type enum anonyme */

Les énumérateurs placés entre accolades sont aussi appelés constantes d'énumération. Chacun reçoit une valeur fixe entière. En l'absence de valeurs d'initialisation explicites, le premier énumérateur dim est égal à zéro, et chaque énumérateur qui suit est incrémenté de un (lun = 1, mar = 2, etc.). Pour plus d'informations sur les constantes d'énumération, voir Constantes d'énumération.

En utilisant des initialisateurs entiers, vous pouvez attribuer des valeurs spécifiques aux énumérateurs. Tous les noms suivants sans initialisateurs seront augmentés de un. Par exemple, dans la déclaration ci-dessous,

/* une expression d'initialisation peut inclure des énumérateurs déjà déclarés */
enum pieces { penny = 1, tuppence, nickel = penny + 4, dime = 10,
             quarter = nickel * nickel } mitraille;

tuppence acquiert la valeur 2, nickel la valeur 5 et quarter la valeur 25.

La valeur d'initialisation est une expression ayant pour résultat une valeur entière positive ou négative (après d'éventuelles conversions en entier). Ces valeurs sont d'habitude uniques, mais elles peuvent être en double.

Les types enum peuvent apparaître chaque fois que int est possible.

enum jours { lun, mar, mer, jeu, ven, sam, dim } touslesjours;
enum jours jours_travail;
typedef enum jours JOURS;
DAYS *joursptr;
int i = mar;
anyday = mon;       // OK
*joursptr = un_jour;  // OK
lun = mar;          // ILLEGAL : lun est une constante

Les balises d'énumération partagent le même espace de nommage que les balises de structure et d'union. Les énumérateurs appartiennent au même espace de nommage que les identificateurs de variables ordinaires :

int lun = 11;
{
   enum jours { lun, mar, mer, jeu, ven, sam, dim } touslesjours;
   /* l'énumérateur lun cache la déclaration externe de int lun */
   struct jours { int i, j;};  // ILLEGAL : sélecteur de jour répété
   double sam;                 // ILLEGAL : redéfinition de sam
}
lun = 12;                      // retour dans portée int lun

En C++, les énumérateurs déclarés dans une classe sont dans la portée de cette classe.

En C++, il est possible de surcharger la plupart des opérateurs d'une énumération. Cependant, comme les opérateurs =, [ ], ( ) et -> doivent être surchargés en tant que fonctions membre, il n'est pas possible de les surcharger pour enum. Voir exemple montrant comment surcharger les opérateurs d'incrémentation suffixe et préfixe.