Énumérations (C++)

Article
10/12/2023

Une énumération est un type défini par l’utilisateur qui se compose d’un ensemble de constantes intégrales nommées appelées énumérateurs.

Remarque

Cet article traite du type de langage enum C++ ISO Standard et du type délimité (ou fortement typé) enum class introduit en C++11. Pour plus d’informations sur les public enum class types en C++/CLI et C++/CX, consultez enum class (C++/CLI et C++/CX)private enum class.

Syntaxe

enum-name:
identifier

enum-specifier:
enum-head{enumerator-list_opt}
enum-head { enumerator-list , }

enum-head:
enum-keyattribute-specifier-seq_optenum-head-name_optenum-base_opt

enum-head-name:
nested-name-specifier_optidentifier

opaque-enum-declaration:
enum-keyattribute-specifier-seq_optenum-head-nameenum-base_opt;

enum-key:
enum
enum class
enum struct

enum-base:
: type-specifier-seq

enumerator-list:
enumerator-definition
enumerator-list , enumerator-definition

enumerator-definition:
enumerator
enumerator = constant-expression

enumerator:
identifierattribute-specifier-seq_opt

Utilisation

// unscoped enum:
// enum [identifier] [: type] {enum-list};

// scoped enum:
// enum [class|struct] [identifier] [: type] {enum-list};

// Forward declaration of enumerations  (C++11):
enum A : int;          // non-scoped enum must have type specified
enum class B;          // scoped enum defaults to int but ...
enum class C : short;  // ... may have any integral underlying type

Paramètres

identifier
Nom de type donné à l'énumération.

type
Type sous-jacent des énumérateurs ; tous les énumérateurs ont le même type sous-jacent. Peut être tout type intégral.

enum-list
Liste délimitée par des virgules des énumérateurs dans l'énumération. Chaque nom d'énumérateur ou de variable dans la portée doit être unique. Toutefois, les valeurs peuvent être dupliquées. Dans une énumération non portée, l’étendue est l’étendue environnante ; dans une énumération délimitée, l’étendue est la enum-list même. Dans une énumération délimitée, la liste peut être vide, qui définit en effet un nouveau type intégral.

class
À l’aide de cette mot clé dans la déclaration, vous spécifiez l’étendue de l’énumération et un identifier doit être fourni. Vous pouvez également utiliser les struct mot clé à la place de class, car elles sont sémantiquement équivalentes dans ce contexte.

Étendue de l’énumérateur

Une énumération fournit un contexte pour décrire une plage de valeurs représentées sous forme de constantes nommées. Ces constantes nommées sont également appelées énumérateurs. Dans les types C et C++ enum d’origine, les énumérateurs non qualifiés sont visibles dans toute l’étendue dans laquelle le enum fichier est déclaré. Dans les énumérations délimitées, le nom de l’énumérateur doit être qualifié par le nom du enum type. L'exemple suivant illustre cette différence fondamentale entre les deux genres d'enums :

namespace CardGame_Scoped
{
    enum class Suit { Diamonds, Hearts, Clubs, Spades };

    void PlayCard(Suit suit)
    {
        if (suit == Suit::Clubs) // Enumerator must be qualified by enum type
        { /*...*/}
    }
}

namespace CardGame_NonScoped
{
    enum Suit { Diamonds, Hearts, Clubs, Spades };

    void PlayCard(Suit suit)
    {
        if (suit == Clubs) // Enumerator is visible without qualification
        { /*...*/
        }
    }
}

À chaque nom d'une énumération est assignée une valeur entière qui correspond à sa place dans l'ordre des valeurs de l'énumération. Par défaut, la première valeur est 0, la suivante 1, et ainsi de suite, mais vous pouvez définir explicitement la valeur d'un énumérateur, comme indiqué ci-dessous :

enum Suit { Diamonds = 1, Hearts, Clubs, Spades };

L'énumérateur Diamonds reçoit la valeur 1. Les énumérateurs suivants, s’ils ne reçoivent pas de valeur explicite, reçoivent la valeur de l’énumérateur précédent plus un. Dans l'exemple précédent, Hearts aurait la valeur 2, Clubs aurait la valeur 3, et ainsi de suite.

Chaque énumérateur est traité comme une constante et doit avoir un nom unique dans l’étendue où l’énumération enum est définie (pour les énumérations non portées) ou dans l’autre enum (pour les énumérations délimitées). Les valeurs données aux noms n’ont pas besoin d’être uniques. Par exemple, considérez cette déclaration d’une énumération Suitnon étendue :

enum Suit { Diamonds = 5, Hearts, Clubs = 4, Spades };

Les valeurs de Diamonds, , ClubsHearts, et Spades sont respectivement 5, 6, 4 et 5. Notez que 5 est utilisé plusieurs fois ; elle est autorisée même si elle n’est peut-être pas prévue. Ces règles sont les mêmes pour les enums délimités.

Règles de transtypage

Les constantes d’énumération non portées peuvent être converties implicitement en int, mais une int valeur d’énumération n’est jamais implicitement convertible. L’exemple suivant montre ce qui se passe si vous essayez d’affecter hand une valeur qui n’est pas un Suit:

int account_num = 135692;
Suit hand;
hand = account_num; // error C2440: '=' : cannot convert from 'int' to 'Suit'

Un cast est nécessaire pour convertir un int énumérateur délimité ou non délimité. Toutefois, vous pouvez promouvoir un énumérateur nonscope en une valeur entière sans cast.

int account_num = Hearts; //OK if Hearts is in an unscoped enum

L'utilisation des conversions implicites de cette façon peut provoquer des effets secondaires inattendus. Pour aider à éliminer les erreurs de programmation associées aux enums non délimités, les valeurs d'enums délimités sont fortement typées. Les énumérateurs délimités doivent être qualifiés par le nom de type d’énumération (identificateur) et ne peuvent pas être convertis implicitement, comme illustré dans l’exemple suivant :

namespace ScopedEnumConversions
{
    enum class Suit { Diamonds, Hearts, Clubs, Spades };

    void AttemptConversions()
    {
        Suit hand;
        hand = Clubs; // error C2065: 'Clubs' : undeclared identifier
        hand = Suit::Clubs; //Correct.
        int account_num = 135692;
        hand = account_num; // error C2440: '=' : cannot convert from 'int' to 'Suit'
        hand = static_cast<Suit>(account_num); // OK, but probably a bug!!!

        account_num = Suit::Hearts; // error C2440: '=' : cannot convert from 'Suit' to 'int'
        account_num = static_cast<int>(Suit::Hearts); // OK
    }
}

Notez que la ligne hand = account_num; provoque toujours l'erreur avec les enums non délimités, comme indiqué précédemment. Elle est autorisée avec un cast explicite. Toutefois, avec les enums délimités, la tentative de conversion dans l'instruction suivante, account_num = Suit::Hearts;, n'est plus autorisée sans transtypage explicite.

Énumérations sans énumérateurs

Visual Studio 2017 version 15.3 et ultérieure (disponible avec /std:c++17 et versions ultérieures) : en définissant une énumération (régulière ou étendue) avec un type sous-jacent explicite et aucun énumérateur, vous pouvez introduire en effet un nouveau type intégral qui n’a aucune conversion implicite vers un autre type. En utilisant ce type au lieu de son type sous-jacent intégré, vous pouvez éliminer le risque d’erreurs subtiles causées par des conversions implicites par inadvertance.

enum class byte : unsigned char { };

Le nouveau type est une copie exacte du type sous-jacent, et a donc la même convention d’appel, ce qui signifie qu’il peut être utilisé entre les API sans pénalité de performances. Aucun cast n’est requis lorsque les variables du type sont initialisées à l’aide de l’initialisation de liste directe. L’exemple suivant montre comment initialiser des énumérations sans énumérateurs dans différents contextes :

enum class byte : unsigned char { };

enum class E : int { };
E e1{ 0 };
E e2 = E{ 0 };

struct X
{
    E e{ 0 };
    X() : e{ 0 } { }
};

E* p = new E{ 0 };

void f(E e) {};

int main()
{
    f(E{ 0 });
    byte i{ 42 };
    byte j = byte{ 42 };

    // unsigned char c = j; // C2440: 'initializing': cannot convert from 'byte' to 'unsigned char'
    return 0;
}

Voir aussi

Déclarations d’énumération C
Mots clés