Enumeration declaration

Une énumération est un type distinct dont la valeur est restreinte à une plage de valeurs (voir ci-dessous pour plus de détails), qui peut inclure plusieurs constantes explicitement nommées (" énumérateurs ").

Les valeurs des constantes sont des valeurs d'un type intégral connu comme le type sous-jacent de l'énumération. Une énumération a la même taille , représentation des valeurs , et exigences d'alignement que son type sous-jacent. De plus, chaque valeur d'une énumération a la même représentation que la valeur correspondante du type sous-jacent.

Une énumération est (re)déclarée en utilisant la syntaxe suivante :

Il existe deux types distincts d'énumérations : l'énumération non-scopée (déclarée avec le enum-key enum ) et l'énumération scopée (déclarée avec le enum-key enum class ou enum struct ).

Énumérations non délimitées

Chaque énumérateur devient une constante nommée du type de l'énumération (c'est-à-dire, name ), visible dans la portée englobante, et peut être utilisé partout où des constantes sont requises.

enum Color { red, green, blue };
Color r = red;
switch(r)
{
    case red  : std::cout << "rouge\n";   break;
    case green: std::cout << "vert\n";  break;
    case blue : std::cout << "bleu\n";  break;
}

Chaque énumérateur est associé à une valeur du type sous-jacent. Lorsque = sont fournis dans une enumerator-list , les valeurs des énumérateurs sont définies par ces constant-expression s associées. Si le premier énumérateur n'a pas de = , la valeur associée est zéro. Pour tout autre énumérateur dont la définition n'a pas de = , la valeur associée est la valeur de l'énumérateur précédent plus un.

enum Foo { a, b, c = 10, d, e = 1, f, g = f + c };
//a = 0, b = 1, c = 10, d = 11, e = 1, f = 2, g = 12

Le nom d'une énumération non délimitée peut être omis : une telle déclaration introduit uniquement les énumérateurs dans la portée englobante :

enum { a, b, c = 0, d = a + 2 }; // définit a = 0, b = 1, c = 0, d = 2

Lorsqu'une énumération non délimitée est un membre de classe, ses énumérateurs peuvent être accédés en utilisant les opérateurs d'accès aux membres de classe . et -> :

struct X
{
    enum direction { left = 'l', right = 'r' };
};
X x;
X* p = &x;
int a = X::direction::left; // autorisé uniquement en C++11 et versions ultérieures
int b = X::left;
int c = x.left;
int d = p->left;

struct S
{
    enum E1 : int {};
    enum E1 : int {}; // error: redeclaration of enumeration,
                      // NOT parsed as a zero-length bit-field of type enum E1
};
enum E2 { e1 };
void f()
{
    false ? new enum E2 : int(); // OK: 'int' is NOT parsed as the underlying type
}

Nom d'énumération à des fins de liaison

Une énumération sans nom qui ne possède pas de typedef name for linkage purposes et qui a un énumérateur est désignée, pour les linkage purposes , par son type sous-jacent et son premier énumérateur ; une telle énumération est dite avoir un énumérateur comme name for linkage purposes .

Énumérations délimitées

#include <iostream>
int main()
{
    enum class Color { red, green = 20, blue };
    Color r = Color::blue;
    switch(r)
    {
        case Color::red  : std::cout << "red\n";   break;
        case Color::green: std::cout << "green\n"; break;
        case Color::blue : std::cout << "blue\n";  break;
    }
    // int n = r; // erreur : pas de conversion implicite de l'énumération délimitée vers int
    int n = static_cast<int>(r); // OK, n = 21
    std::cout << n << '\n'; // affiche 21
}

enum byte : unsigned char {}; // byte is a new integer type; see also std::byte (C++17)
byte b{42};        // OK as of C++17 (direct-list-initialization)
byte c = {42};     // error
byte d = byte{42}; // OK as of C++17; same value as b
byte e{-1};        // error
struct A { byte b; };
A a1 = {{42}};     // error (copy-list-initialization of a constructor parameter)
A a2 = {byte{42}}; // OK as of C++17
void f(byte);
f({42}); // error (copy-list-initialization of a function parameter)
enum class Handle : std::uint32_t { Invalid = 0 };
Handle h{42}; // OK as of C++17

enum E { x };
void f()
{
    int E;
    using enum E; // OK
}
using F = E;
using enum F; // OK
template<class T>
using EE = T;
void g()
{
    using enum EE<E>; // OK
}

enum class fruit { orange, apple };
struct S
{
    using enum fruit; // OK: introduit orange et apple dans S
};
void f()
{
    S s;
    s.orange;  // OK: nomme fruit::orange
    S::orange; // OK: nomme fruit::orange
}

enum class fruit { orange, apple };
enum class color { red, orange };
void f()
{
    using enum fruit;    // OK
    // using enum color; // erreur: color::orange et fruit::orange entrent en conflit
}

Notes

Les valeurs de type énumération non délimitée peuvent être promues ou converties en types entiers :

enum color { red, yellow, green = 20, blue };
color col = red;
int n = blue; // n == 21

Les valeurs des types entiers, à virgule flottante et d'énumération peuvent être converties en n'importe quel type d'énumération en utilisant static_cast . Notez que la valeur après une telle conversion peut ne pas nécessairement correspondre à l'un des énumérateurs nommés définis pour l'énumération :

enum access_t { read = 1, write = 2, exec = 4 }; // énumérateurs : 1, 2, 4 plage : 0..7
access_t rwe = static_cast<access_t>(7);
assert((rwe & read) && (rwe & write) && (rwe & exec));
access_t x = static_cast<access_t>(8.0); // comportement indéfini depuis CWG 1766
access_t y = static_cast<access_t>(8);   // comportement indéfini depuis CWG 1766
enum foo { a = 0, b = UINT_MAX }; // plage : [0, UINT_MAX]
foo x = foo(-1); // comportement indéfini depuis CWG 1766,
                 // même si le type sous-jacent de foo est unsigned int

Mots-clés

enum , struct , class , using

Exemple

#include <cstdint>
#include <iostream>
// enum qui prend 16 bits
enum smallenum: std::int16_t
{
    a,
    b,
    c
};
// color peut être red (valeur 0), yellow (valeur 1), green (valeur 20), ou blue (valeur 21)
enum color
{
    red,
    yellow,
    green = 20,
    blue
};
// altitude peut être altitude::high ou altitude::low
enum class altitude: char
{
    high = 'h',
    low = 'l', // virgule finale uniquement autorisée après CWG 518
}; 
// la constante d est 0, la constante e est 1, la constante f est 3
enum
{
    d,
    e,
    f = e + 2
};
// les types énumération (scopés et non scopés) peuvent avoir des opérateurs surchargés
std::ostream& operator<<(std::ostream& os, color c)
{
    switch(c)
    {
        case red   : os << "red";    break;
        case yellow: os << "yellow"; break;
        case green : os << "green";  break;
        case blue  : os << "blue";   break;
        default    : os.setstate(std::ios_base::failbit);
    }
    return os;
}
std::ostream& operator<<(std::ostream& os, altitude al)
{
    return os << static_cast<char>(al);
}
// L'énumération scopée (C++11) peut être partiellement émulée dans les révisions antérieures de C++ :
enum struct E11 { x, y }; // depuis C++11
struct E98 { enum { x, y }; }; // OK en pré-C++11
namespace N98 { enum { x, y }; } // OK en pré-C++11
struct S98 { static const int x = 0, y = 1; }; // OK en pré-C++11
void emu()
{
    std::cout << (static_cast<int>(E11::y) + E98::y + N98::y + S98::y) << '\n'; // 4
}
namespace cxx20
{
    enum class long_long_long_name { x, y };
    void using_enum_demo()
    {
        std::cout << "C++20 `using enum`: __cpp_using_enum == ";
        switch (auto rnd = []{return long_long_long_name::x;}; rnd())
        {
#if defined(__cpp_using_enum)
            using enum long_long_long_name;
            case x: std::cout << __cpp_using_enum << "; x\n"; break;
            case y: std::cout << __cpp_using_enum << "; y\n"; break;
#else
            case long_long_long_name::x: std::cout << "?; x\n"; break;
            case long_long_long_name::y: std::cout << "?; y\n"; break;
#endif
        }
    }
}
int main()
{
    color col = red;
    altitude a;
    a = altitude::low;
    std::cout << "col = " << col << '\n'
              << "a = "   << a   << '\n'
              << "f = "   << f   << '\n';
    cxx20::using_enum_demo();
}

col = rouge
a = l
f = 3
C++20 `using enum`: __cpp_using_enum == 201907; x

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi