Type énuméré

Cet article est une ébauche concernant l’informatique.

Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

Pour les articles homonymes, voir Enum.

En programmation informatique, un type énuméré (appelé souvent énumération ou juste enum, parfois type énumératif ou liste énumérative) est un type de données qui consiste en un ensemble de valeurs constantes. Ces différentes valeurs représentent différents cas ; on les nomme énumérateurs^{[réf. nécessaire]}. Lorsqu'une variable est de type énuméré, elle peut avoir comme valeur n'importe quel cas de ce type énuméré.

Un exemple typique est la représentation de cartes à jouer ordinaires : la suite ("couleur") ainsi que la hauteur (nombre ou figure) de la carte peuvent être représentés par des énumérations. Dans certains langages, le type booléen (logique) est un type énuméré prédéfini qui possède deux énumérateurs (true et false). Toutefois, les énumérateurs sont souvent écrits en majuscule afin d'indiquer que ce sont des constantes.

Syntaxe et fonctionnement

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

Langage C

En C et avec les langages syntaxiquement proches :

//** ****************************************
//** Fichier de déclaration
//** ****************************************

//## Déclaration d'un type personnalisé (liste énumérative).
enum TCouleurCarte
{
   ccTrefle,
   ccCarreau,
   ccCoeur,
   ccPique
};

//## Déclaration d'un type personnalisé (structure).
struct TCarte
{
   enum TCouleurCarte Couleur;
   short int          Valeur;
};

//** ****************************************
//** Fichier d'implémentation
//** ****************************************

//** Définition d'une variable 
//** à partir du type personnalisé (structure).
struct TCarte MaMain[5];

//** Définition d'une variable 
//** à partir du type personnalisé (liste énumérative).
enum TCouleurCarte Atout;

//   Affecter une valeur à l'atout.
Atout = ccTrefle;

//   Affecter une valeur à l'une des cartes de la main.
MaMain[2].Couleur = ccCoeur;
MaMain[2].Valeur  = 10;

En C, les énumérateurs ont une portée globale ou limitée à un bloc. Ils sont équivalents à des entiers. Le premier énumérateur vaut zéro, tandis que tous les suivants correspondent à leur précédent incrémenté de un. Il est possible de choisir explicitement les valeurs des constantes d'énumération (ou de certaines d'entre elles ; dans ce cas, les autres suivent la règle donnée précédemment), comme dans :

enum TCouleurCarte {
    ccTrefle  = 12,
    ccCarreau = 21,
    ccCoeur   = 5,
    ccPique   = 17
};

Source

• « Chapitre 10: Les types avancées [partie II] », sur www.apprendre-informatique.com (consulté le 13 décembre 2016) (section Les énumérations).
• « Langage C++ : Enumérations », sur fr.wikiversity.org (consulté le 13 décembre 2016).
• « Programmation C/Types avancés », sur fr.wikibooks.org (consulté le 13 décembre 2016) (section Énumérations).
• « Déclarations d'énumération C », sur msdn.microsoft.com (consulté le 13 décembre 2016)
• « Chapitre 2 Les types énumérés », sur lacl.u-pec.fr (consulté le 13 décembre 2016) (PDF)
• « Créez vos propres types de variables », sur openclassrooms.com (consulté le 13 décembre 2016) (section Les énumérations)
• « Les énumérations », sur c.developpez.com (consulté le 13 décembre 2016)
• « Apprenez à programmer en Java - Les énumérations », sur openclassrooms.com (consulté le 13 décembre 2016)
• « Chapître 2 - Introduction au langage C », sur www.lacim.uqam.ca (consulté le 13 décembre 2016) (page 20: type énumératif)

• Portail de la programmation informatique