Vidéo: Tutoriel C++ - énumérations fortement typées 2025
La programmation est une question de lisibilité. Il est difficile (en fait c'est impossible) d'écrire et de maintenir un programme que vous ne pouvez pas lire. Une partie de la lecture d'une liste de codes source consiste à comprendre ce que les chiffres utilisés dans le programme représentent. L'aide la plus élémentaire que fournit C ++ est l'omniprésente #define, comme dans l'exemple souvent cité:
#define PI 3. 141592653589793
Cette solution est acceptable pour les valeurs individuelles, bien qu'elle souffre du fait que le Le mécanisme #define n'est pas (strictement parlant) une partie de C / C ++ puisque le préprocesseur s'exécute avant le compilateur. En réponse à cela, C ++ 2011 a introduit une construction expression constante :
constexpr long double PI = 3. 141592653589793;
Le mot-clé constexpr introduit des constantes dans la tente C ++. Ce PI a un type réel, comme les autres variables C ++. C ++ peut générer des messages d'erreur avec PI qui ont beaucoup plus de sens que ceux impliquant 3. 14159.
Les expressions constantes conviennent aux valeurs constantes individuelles, mais souvent les constantes représentent des ensembles de choses plutôt que des constantes naturelles, comme dans l'exemple suivant:
#define DC_OR_TERRITORY 0 #define ALABAMA 1 #define ALASKA 2 #define ARKANSAS 3 // … et ainsi de suite …
On peut supposer que ces constantes sont utilisées pour identifier les états, peut-être utilisés comme un index dans un tableau d'objets d'état ou en tant que valeur dans une base de données quelque part.
C ++ a longtemps eu un mécanisme amélioré pour définir ces types de constantes - l'énumération:
enum STATE {DC_OR_TERRITORY, // obtient 0 ALABAMA, // obtient 1 ALASKA, // obtient 2 ARKANSAS, // … et bientôt…};
Le mot-clé enum introduit une séquence de constantes appelée "énumération". Dans ce cas, l'énumération porte le nom STATE. Chaque élément de cette énumération reçoit une valeur commençant à 0 et augmentant séquentiellement de 1, donc DC_OR_TERRITORY est défini comme 0, ALABAMA est défini sur 1, et ainsi de suite. Vous pouvez remplacer ce séquençage incrémental en utilisant une instruction assign comme suit:
enum STATE {DC, TERRITOIRE = 0, ALABAMA, ALASKA, // … et ainsi de suite …};
Cette version de STATE définit un élément DC, qui reçoit la valeur 0. Il définit ensuite un nouvel élément TERRITORY, auquel est également affectée la valeur 0. ALABAMA décroche avec 1, comme précédemment.
En pratique, le programmeur peut utiliser des énumérations pour écrire du code très lisible comme:
double taxRate (STATE s) {return taxRatesByState [s];}
Le seul problème de cette approche est que cette énumération ne crée pas un nouveau type (comme vous pourriez le penser).En fait, selon la norme, STATE est juste un autre nom pour int - et les constantes ALABAMA, ALASKA, et ainsi de suite sont tous de type const int.
Le compilateur gcc fournit réellement une énumération déclarée de cette manière un peu plus d'autorité que de simplement l'appeler une autre forme de int. Vous pouvez réellement surcharger des fonctions basées sur un type enum:
void fn (STATE s); void fn (int n); fn (ALASKA); // appelle fn (STATE)
La norme 2011 permet au programmeur de créer un type complètement nouveau en utilisant le mot-clé enum. Les créateurs de la nouvelle norme ne voulant pas casser le code existant, la norme requiert l'ajout d'un mot-clé supplémentaire pour définir un type d'énumération, comme dans l'exemple suivant:
enum class ETAT {DC, TERRITOIRE = 0, ALABAMA, ALASKA, // … et ainsi de suite …};
Une classe d'énumération est maintenant un type à échelle réelle comme toute autre classe définie par l'utilisateur. Ce qui suit n'est même plus légal pour deux raisons:
int s = ALASKA;
Premièrement, la constante ALASKA n'est définie que dans l'espace de noms STATE. Ainsi, le nom de la constante est STATE:: ALASKA. Deuxièmement, le type n'est pas int mais STATE. Vous ne pouvez pas affecter une valeur de type STATE à un int.
ETAT s = ETAT:: ALASKA;
Le programmeur peut transformer un STATE en un int mais il doit le faire explicitement - les conversions implicites ne le coupent pas avec les classes d'énumération:
int n = (int) STATE:: ALASKA;
Ce nouveau type d'énumération peut également être basé sur l'un des autres types de nombres compteurs sauf int:
enum class STATE: char {DC, // … le reste de la déclaration est identique
