Déclaration, définition et utilisation des énumérateurs enum en C++, et explication détaillée des énumérations fortement typées

Déclaration, définition et utilisation des énumérateurs

Comme nous le savons tous, le langage C/C++ peut utiliser#defineetconstpour créer des constantes symboliques, et utiliserenumL'outil peut non seulement créer des constantes symboliques, mais aussi définir de nouveaux types de données, mais cela doit être fait selon certaines règles. Regardons l'utilisation deenum.

Étape (1) — Déclaration et définition des énumérateurs

(1) Tout d'abord, regardez l'instruction suivante :

enum enumType {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

Cette instruction a deux fonctions :

Premièrement : elle déclare enumType comme un nouveau type de données, appelé une énumération ;
Deuxièmement : elle déclare Monday, Tuesday, etc. comme des constantes symboliques, habituellement appelées énumérateurs, dont les valeurs par défaut sont respectivement 0-6. (Nous présenterons plus tard comment initialiser explicitement les valeurs des énumérateurs.)

(2)Ensuite, utilisez le nouveau type d'énumération enumType pour déclarer des variables de ce type : enumType Weekday, tout comme on déclare une variable avec le type de variable de base int, par exemple, int a; vous pouvez également définir des variables d'énumération lors de la définition du type d'énumération.

enum enumType {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}Weekday;

Toutefois, contrairement aux types de variables de base, sans conversion explicite (cast), vous pouvez uniquement affecter les énumérateurs définis à une variable de ce type d'énumération. Par exemple : Weekday = Monday; ou Weekday = Sunday; Vous ne pouvez pas affecter d'autres valeurs à une variable d'énumération, par ex., Weekday = 10; Ce n'est pas autorisé car 10 n'est pas un énumérateur. En d'autres termes, Weekday ne peut être que les énumérateurs définis Monday-Sunday. Mais ce n'est pas absolu ; le sixième point abordera l'utilisation d'un cast pour affecter des valeurs d'autres types à des variables d'énumération.

(3)Il a été indiqué ci-dessus que des valeurs qui ne sont pas des énumérateurs ne peuvent pas être affectées à des variables d'énumération. Alors, des énumérateurs peuvent-ils être affectés à des variables qui ne sont pas d'énumération ? Par exemple :int a=Monday;Cela est autorisé, car les énumérateurs sont des constantes symboliques. Dans cette affectation, le compilateur convertira automatiquement l'énumérateur en type int.

(4)Plus haut, nous avons dit que des opérations d'affectation peuvent être effectuées sur des énumérations. Les variables d'énumération peuvent-elles subir des opérations arithmétiques ?

Weekday++;Weekday = Monday + Tuesday;

C'est illégal, car ces opérations peuvent entraîner des violations des restrictions de type. Par exemple :

Weekday = Sunday;
Weekday++;

Weekday se voit d'abord affecter la valeur du dernier énumérateur Sunday (valeur 6). Si on l'incrémente davantage, Weekday passerait à 7, mais 7 n'est pas valide pour le type enumType.

Résumé :Pour les énumérations, seul l'opérateur d'affectation est défini ; les opérations arithmétiques ne sont pas définies pour les énumérations.

(5)Des opérations arithmétiques ne peuvent pas être effectuées sur des énumérateurs. Alors, les énumérateurs peuvent-ils participer à des opérations avec des variables d'autres types ?

int a;
a = 1 + Monday;

Cela est autorisé, car le compilateur convertira automatiquement les énumérateurs en type int.

(6)Le deuxième point indiquait : sans transtypage, seuls les énumérateurs définis peuvent être affectés à une variable de ce type d'énumération. Cela implique que des valeurs d'autres types peuvent être affectées à des variables d'énumération au moyen d'un transtypage :

Weekday = enumType(2);

Équivalent à :

Weekday = Wednesday;

Mais que se passerait-il si vous tentiez d'affecter une valeur en dehors de la plage de valeurs de l'énumération à une variable d'énumération au moyen d'un transtypage ?

Weekday = enumType(20);

Le résultat sera indéfini. Cela ne provoquera pas d'erreur, mais vous n'obtiendrez pas le résultat souhaité.

Étape (2) — Personnalisation des valeurs d'énumérateur

(1)Précédemment, nous avons parlé de la définition deenum enumType {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};Les énumérateurs Monday, Tuesday, etc. ont respectivement des valeurs par défaut de 0 à 6. Nous pouvons définir explicitement les valeurs des énumérateurs :

enum enumType {Monday=1, Tuesday=2, Wednesday=3, Thursday=4, Friday=5, Saturday=6, Sunday=7};

Les valeurs spécifiées doivent être des entiers !

(2)Vous pouvez également définir explicitement seulement certaines des valeurs d'énumérateur :

enum enumType {Monday=1, Tuesday, Wednesday=1, Thursday, Friday, Saturday, Sunday};

De cette manière, Monday et Wednesday sont tous deux définis comme 1, donc Tuesday=2, et les valeurs par défaut de Thursday, Friday, Saturday et Sunday sont respectivement 2, 3, 4, 5.

Résumé :La valeur d'un énumérateur non initialisé vaut par défaut 1 de plus que la valeur de l'énumérateur précédent.

(3)Le deuxième point illustre également un autre phénomène : les valeurs d'énumérateur peuvent être identiques.

Étape (3) — La plage de valeurs d'une énumération

Précédemment, il a été mentionné que des valeurs d'autres types peuvent être affectées à des variables d'énumération au moyen d'un transtypage :

Weekday = enumType(2);

Ceci est légal ;

Mais

Weekday = enumType(20);

est illégal. Cela implique le concept de plage de valeurs d'une énumération : la borne supérieure d'une énumération est la plus petite puissance de 2 qui est supérieure à l'énumérateur maximal, moins 1 ;

La borne inférieure d'une énumération a deux cas : 1. Si la valeur minimale de l'énumérateur n'est pas inférieure à 0, la borne inférieure est 0 ; 2. Si la valeur minimale de l'énumérateur est inférieure à 0, la borne inférieure est la plus grande puissance de 2 qui est inférieure à l'énumérateur minimal, plus 1.

Par exemple :

Supposons que nous définissionsenum enumType1 { First=-5，Second=14，Third=10 };Alors la borne supérieure de l'énumération est 16-1=15 (16 est supérieur à l'énumérateur maximal 14, et est une puissance de 2) ; la borne inférieure est -8+1=-7 (-8 est inférieur à l'énumérateur minimal -5, et est une puissance de 2).

Étape (4) — Applications des énumérations

Personnellement, je pense que enum et switch sont les meilleurs partenaires :

enum enumType{Step0, Step1, Step2}Step=Step0; // 注意这里在声明枚举的时候直接定义了枚举变量 Step,并初始化为 Step0

switch (Step)x
{
  case Step0:{...;break;}
  case Step1:{...;break;}
  case Step2:{...;break;}
  default:break;
}

De plus, il existe un usage rare de enum, qui estenum { one ,two ,three};c'est-à-dire ne pas spécifier de nom. De cette façon, naturellement, nous ne pouvons pas définir de types d'énumération. À ce stade, cela équivaut àstatic const int one = 0;définir trois constantes comme ceci. Ensuite, lors de l'utilisation, vous écrivez simplementint no = one。

Énumérations fortement typées

1. Brève description

Les énumérations fortement typées, également appelées classes enum, sont une nouvelle syntaxe en C++11, utilisée pour résoudre les défauts des types d'énumération traditionnels de C++. En C++ traditionnel, les constantes d'énumération sont exposées à la portée extérieure, donc si deux types d'énumération différents se trouvent dans la même portée, ils ne peuvent pas contenir la même constante d'énumération. Par exemple :

enum Side{Right,Left};
enum Thing{Wrong,Right};

Ils ne peuvent pas être utilisés ensemble.

Un autre défaut est que les valeurs d'énumération traditionnelles sont toujours implicitement converties en entiers, et les utilisateurs ne peuvent pas définir le type sous-jacent. Les énumérations fortement typées de C++11 résolvent ces problèmes.

2. Énumérations fortement typées

Les énumérations fortement typées utilisent la syntaxe `enum class` pour se déclarer, comme suit :

enum class Enumeration{
    VAL1,
    VAL2,
    VAL3=100,
    VAL4
};

De cette façon, le type d'énumération est sûr, et les valeurs d'énumérateur ne seront pas implicitement converties en entiers, et ne pourront pas non plus être comparées à des valeurs entières. Par exemple (`Enumeration::VAL4 == 10` déclenchera une erreur de compilation).

De plus, le type sous-jacent utilisé par le type d'énumération est par défaut `int`, mais d'autres types peuvent aussi être spécifiés, par exemple :

enum class Enum:unsigned int{VAL1,VAL2};

Comme mentionné précédemment, les énumérations fortement typées peuvent résoudre le problème des énumérations traditionnelles ayant les mêmes noms d'énumérateurs dans différentes classes d'énumération. Lors de l'utilisation d'un énumérateur d'un type d'énumération, vous devez spécifier sa portée, par exemple : `Enum::VAL1`, tandis que `VAL1` seul n'a plus de sens.

Un autre point à noter est que la déclaration anticipée des types d'énumération est également possible en C++11, par exemple :

enum class Enum;
enum class Enum1:unsigned int;

3. Extraits de code d'énumérations fortement typées dans des projets

1. Traitement d'image

enum class Color{RED,BLUE,YELLOR,BLACK,WHITE};

2. Feux de circulation

enum class TrafficLight{RED,YELLOR,GREEN};

Les énumérateurs fortement typés ont la fonctionnalité des énumérations traditionnelles — nommer les valeurs d'énumérateur — et possèdent également des caractéristiques de classe : ils ont des membres à portée de classe et ne peuvent pas subir de conversion de type par défaut. Par conséquent, ils sont aussi appelés classes d'énumération — `enum class`.

Le type de données sous-jacent d'une classe d'énumération doit être un type entier signé ou non signé, tel que `char`, `unsigned int`, `unsigned long` ; la valeur par défaut est `int`.

3. Application de la déclaration anticipée

enmu class Clolor:char;            //前置声明枚举类
void Foo(Color*p);                     //前置声明的使用
//....................
enum class Color:char{RED,GREEN,BLACK,WHITE};      //前置声明的定义

Référence : http://blog.csdn.net/u012333003/article/details/20612267

Explication détaillée de la déclaration, de la définition et de l'utilisation des énumérateurs enum en C++, ainsi que des énumérations fortement typées

Catégorie Technologie de programmation