Énumérations

La définition de noms symboliques de constantes dans un programme simplifie le processus de lisibilité et de mise à jour ultérieure du programme. Une méthode consiste à définir une énumération, qui associe un ensemble de nombres entiers à un ensemble d'identificateurs, appelés énumérateurs, que le compilateur reconnaît et remplace par la valeur entière correspondante. Une énumération est définie à l'aide d'une déclaration comme suit :

enum colors {
	RED,
	GREEN,
	BLUE
};

Le premier énumérateur de l'énumération, RED, reçoit la valeur zéro et chaque identificateur ultérieur reçoit la valeur entière suivante. Vous pouvez également attribuer une valeur entière spécifique à un énumérateur en lui donnant un suffixe comprenant un signe égal (=) et une constante entière, comme dans l'exemple suivant :

enum colors {
	RED = 7,
	GREEN = 9,
	BLUE
};

Le compilateur assigne à l'énumérateur BLUE la valeur 10, car aucune n'est spécifiée et que l'énumérateur précédent est défini sur 9. Une fois l'énumération définie, vous pouvez utiliser les énumérateurs dans tout programme en D où une constante entière peut être utilisée. Par ailleurs, l'énumération enum colors est également définie comme un type équivalant à int. Le compilateur D permettra également d'utiliser une variable de type enum chaque fois que vous pouvez utiliser int, ainsi que d'affecter une valeur entière à une variable de type enum. Vous pouvez également omettre le nom enum dans la déclaration si le nom du type n'est pas requis.

Les énumérateurs sont visibles dans toutes les clauses et déclarations ultérieures de votre programme, de sorte que vous pouvez définir le même identificateur d'énumérateur dans plusieurs énumérations. Vous pouvez, cependant, définir plusieurs énumérateurs possédant la même valeur dans la même ou dans différentes énumérations. Vous pouvez également affecter à une variable de type énumération des nombres entiers ne possédant aucun énumérateur correspondant.

La syntaxe d'énumération en D est identique à la syntaxe correspondante en ANSI-C. Le langage D permet également d'accéder aux énumérations définies dans le noyau du système et ses modules chargeables. Ces énumérateurs ne sont toutefois pas visibles globalement dans votre programme en D. Les énumérateurs du noyau ne sont visibles que lorsqu'ils sont utilisés comme argument vers les opérateurs de comparaison binaire dans le cadre d'une comparaison avec un objet du type d'énumération correspondant. Par exemple, la fonction uiomove(9F) possède un paramètre de type enum uio_rw défini comme suit :

enum uio_rw { UIO_READ, UIO_WRITE };

Les énumérateurs UIO_READ et UIO_WRITE ne sont logiquement pas visibles dans votre programme en D. Vous pouvez toutefois leur conférer une visibilité globale en en comparant un avec une valeur de type enum uio_rw, comme illustré dans l'exemple de clause suivant :

fbt::uiomove:entry
/args[2] == UIO_WRITE/
{
	...
}

Cet exemple suit les appels à la fonction uiomove(9F) pour les demandes d'écriture en comparant args[2], une variable de type enum uio_rw, à l'énumérateur UIO_WRITE. Comme l'argument de gauche est un type d'énumération, le compilateur D recherche l'énumération lorsqu'il essaye de résoudre l'identificateur de droite. Cette fonction protège vos programmes en D des conflits de noms d'identificateurs avec les nombreuses énumérations définies dans le noyau du système d'exploitation.