classe d'enum
Déclare une énumération au namespace scope, qui est un type défini par l'utilisateur qui se compose d'un jeu de constantes nommées appelées énumérateurs.
Tous les runtimes
Remarques
C++/CX et C++/CLI prennent en charge les classes public enum class et private enum class qui sont semblables à la classe C++ standard enum class, avec ajout du spécificateur d'accessibilité. Sous /clr, le type enum class C++11 est autorisé mais générera l'avertissement C4472 destiné à garantir que vous souhaitez réellement le type enum ISO et non le type C++/CX et de C++/CLI. Pour plus d'informations sur le standard ISO C++, enum, consultez Déclarations d'énumération C++.
Windows Runtime
Syntaxe
access enum class enumeration-identifier [:underlying-type] { enumerator-list } [var];
access enum struct enumeration-identifier [:underlying-type] { enumerator-list } [var];
Paramètres
access
L'accessibilité de l'énumération, qui peut être public ou private.enumeration-identifier
Nom de l'énumération.underlying-type
(Facultatif) Type sous-jacent de l'énumération.(Facultatif. Windows Runtime uniquement) Type sous-jacent de l'énumération, qui peut être bool, char, char16, int16, uint16, int, uint32, int64 ou uint64.
enumerator-list
Une liste, délimitée par des virgules, de noms d'énumérateurs.La valeur de chaque énumérateur est une expression constante qui est définie implicitement par le compilateur ou explicitement par la notation, enumerator = expression constante. Par défaut, la valeur du premier énumérateur est zéro s'il est défini implicitement. La valeur de chaque énumérateur suivant implicitement défini est la valeur de l'énumérateur précédent + 1.
var
(Facultatif) Nom d'une variable du type énumération.
Remarques
Pour plus d'informations et d'exemples, consultez Enums.
Notez que le compilateur émet des messages d'erreur si l'expression constante qui définit la valeur d'un énumérateur ne peut pas être représentée par le type sous-jacent. Toutefois, le compilateur ne signale pas d'erreur pour une valeur qui n'est pas appropriée pour le type sous-jacent. Par exemple :
Si le type sous-jacent est numérique et si un énumérateur spécifie la valeur maximale pour ce type, la valeur de la prochaine énumération implicitement définie ne peut pas être représentée.
Si le type sous-jacent est booléen et si plus de deux énumérateurs sont implicitement définis, les énumérateurs au-delà des deux premiers ne peuvent pas être représentés.
Si le type sous-jacent est char16, et si la valeur d'énumération s'étend de 0xD800 à 0xDFFF, la valeur peut être représentée. Toutefois, la valeur est logiquement incorrecte, car elle représente la moitié d'une paire de substitution Unicode et ne doit pas s'afficher de manière isolée.
Configuration requise
Option du compilateur : /ZW
Common Language Runtime
Syntaxe
access enum class name [:type] { enumerator-list } var;
access enum struct name [:type] { enumerator-list } var;
Paramètres
access
L'accessibilité de l'enum. Peut être public ou private.enumerator-list
Liste, délimitée par des virgules, des identificateurs (énumérateurs) dans l'énumération.name
Nom de l'énumération. Les énumérations managées anonymes ne sont pas autorisées.type (facultatif)
Type sous-jacent des identifiants. Cela peut être tout type scalaire, tel que les versions signées ou non signées d'int, short ou long. Les bool ou les char sont aussi permis.var (facultatif)
Nom d'une variable du type énumération.
Remarques
enum class et enum struct sont des déclarations équivalentes.
Il existe deux types d'enums : managé ouC++/CX et standard.
Un enum managé ou C++/CX peut être défini de la façon suivante,
public enum class day {sun, mon };
et équivaut sémantiquement à :
ref class day {
public:
static const int sun = 0;
static const int mon = 1;
};
Un enum standard peut être défini de la façon suivante :
enum day2 { sun, mon };
et équivaut sémantiquement à :
static const int sun = 0;
static const int mon = 1;
Les noms d'énumérateur managés (identificateurs) ne sont pas injectés dans la portée où l'énumération est définie ; toutes les références aux énumérateurs doivent être qualifiées complètes (nom::identificateur). Pour cette raison, vous ne pouvez pas définir un enum managé anonyme.
Les énumérateurs d'un enum standard sont fortement injectés dans la portée englobante. Autrement dit, s'il existe un autre symbole qui porte le même nom qu'un énumérateur de la portée englobante, le compilateur génèrera une erreur.
Dans Visual C++ 2002 et Visual C++ 2003, les énumérateurs étaient injectés faiblement (visibles dans la portée englobante sauf s'il y avait un autre identificateur avec le même nom).
Si un enum C++ standard est défini (sans class ou struct), la compilation avec /clr entraîne la compilation de l'énumération en tant qu'enum managé. L'énumération conserve la sémantique d'une énumération non managée. Notez que le compilateur injecte un attribut [Microsoft::VisualC::NativeEnumAttribute], reconnu par le compilateur Visual C++, pour identifier l'intention d'un programmeur d'obtenir un enum natif. D'autres compilateurs verront simplement l'enum standard comme un enum managé.
Un enum nommé et standard compilé avec /clr sera visible dans l'assembly comme un enum managé. Il peut être consommé par tout autre compilateur managé. Toutefois, un enum standard sans nom ne sera pas visible publiquement à partir de l'assembly.
Dans Visual C++ 2002 et Visual C++ 2003, un énumérateur standard utilisé comme type d'un paramètre de fonction :
// mcppv2_enum.cpp
// compile with: /clr
enum E { a, b };
void f(E) {System::Console::WriteLine("hi");}
int main() {
E myi = b;
f(myi);
}
émettrait ce qui suit en MSIL pour la signature de la fonction :
void f(int32);
Toutefois, dans les versions actuelles du compilateur, l'enum standard est émis en tant qu'enum managé avec un [NativeEnumAttribute] et le suivant est émis en MSIL pour la signature de la fonction :
void f(E)
Pour plus d'informations sur les enums natifs, consultez Déclarations d'énumération C++.
Pour plus d'informations sur les enums CLR, consultez :
Configuration requise
Option du compilateur : /clr
Exemples
Exemple
desc
// mcppv2_enum_2.cpp
// compile with: /clr
// managed enum
public enum class m { a, b };
// standard enum
public enum n { c, d };
// unnamed, standard enum
public enum { e, f } o;
int main()
{
// consume managed enum
m mym = m::b;
System::Console::WriteLine("no automatic conversion to int: {0}", mym);
System::Console::WriteLine("convert to int: {0}", (int)mym);
// consume standard enum
n myn = d;
System::Console::WriteLine(myn);
// consume standard, unnamed enum
o = f;
System::Console::WriteLine(o);
}
Sortie