Enumeration declaration

Перечисление — это отдельный тип, значение которого ограничено диапазоном значений (подробности см. ниже), который может включать несколько явно именованных констант (" перечислителей ").

Значения констант являются значениями целочисленного типа, известного как базовый тип перечисления. Перечисление имеет тот же размер , представление значений и требования к выравниванию , что и его базовый тип. Кроме того, каждое значение перечисления имеет то же представление, что и соответствующее значение базового типа.

Перечисление объявляется (или переобъявляется) с использованием следующего синтаксиса:

Существует два различных вида перечислений: unscoped enumeration (объявляется с помощью enum-key enum ) и scoped enumeration (объявляется с помощью enum-key enum class или enum struct ).

Неограниченные перечисления

Каждый enumerator становится именованной константой типа перечисления (то есть, name ), видимой в охватывающей области видимости, и может использоваться там, где требуются константы.

enum Color { red, green, blue };
Color r = red;
switch(r)
{
    case red  : std::cout << "красный\n";   break;
    case green: std::cout << "зеленый\n"; break;
    case blue : std::cout << "синий\n";  break;
}

Каждый перечислитель связан со значением базового типа. Когда = указаны в enumerator-list , значения перечислителей определяются соответствующими constant-expression . Если первый перечислитель не имеет = , связанное значение равно нулю. Для любого другого перечислителя, определение которого не содержит = , связанное значение равно значению предыдущего перечислителя плюс один.

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

Имя неограниченного перечисления может быть опущено: такое объявление только вводит перечислители в охватывающую область видимости:

enum { a, b, c = 0, d = a + 2 }; // определяет a = 0, b = 1, c = 0, d = 2

Когда неограниченное перечисление является членом класса, его перечислители могут быть доступны с использованием операторов доступа к членам класса . и -> :

struct X
{
    enum direction { left = 'l', right = 'r' };
};
X x;
X* p = &x;
int a = X::direction::left; // разрешено только в C++11 и позднее
int b = X::left;
int c = x.left;
int d = p->left;

struct S
{
    enum E1 : int {};
    enum E1 : int {}; // ошибка: переопределение перечисления,
                      // НЕ анализируется как битовое поле нулевой длины типа enum E1
};
enum E2 { e1 };
void f()
{
    false ? new enum E2 : int(); // OK: 'int' НЕ анализируется как базовый тип
}

Имя перечисления для целей компоновки

Безымянное перечисление, которое не имеет typedef-имени для целей линковки и которое имеет перечислитель, обозначается, для целей линковки , своим базовым типом и первым перечислителем; такое перечисление считается имеющим перечислитель в качестве имени для целей линковки .

Областные перечисления

#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; // ошибка: нет неявного преобразования из ограниченного enum в int
    int n = static_cast<int>(r); // OK, n = 21
    std::cout << n << '\n'; // выводит 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: вводит orange и apple в S
};
void f()
{
    S s;
    s.orange;  // OK: ссылается на fruit::orange
    S::orange; // OK: ссылается на fruit::orange
}

enum class fruit { orange, apple };
enum class color { red, orange };
void f()
{
    using enum fruit;    // OK
    // using enum color; // ошибка: color::orange и fruit::orange конфликтуют
}

Примечания

Значения неперечислимого типа могут быть повышены или преобразованы в целочисленные типы:

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

Значения целочисленных, чисел с плавающей точкой и перечисляемых типов могут быть преобразованы в любой перечисляемый тип с использованием static_cast . Обратите внимание, что значение после такого преобразования может не обязательно равняться какому-либо из именованных перечислителей, определённых для перечисления:

enum access_t { read = 1, write = 2, exec = 4 }; // перечислители: 1, 2, 4 диапазон: 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); // неопределённое поведение с CWG 1766
access_t y = static_cast<access_t>(8);   // неопределённое поведение с CWG 1766
enum foo { a = 0, b = UINT_MAX }; // диапазон: [0, UINT_MAX]
foo x = foo(-1); // неопределённое поведение с CWG 1766,
                 // даже если базовый тип foo - unsigned int

Ключевые слова

enum , struct , class , using

Пример

#include <cstdint>
#include <iostream>
// enum, занимающий 16 бит
enum smallenum: std::int16_t
{
    a,
    b,
    c
};
// color может быть red (значение 0), yellow (значение 1), green (значение 20) или blue (значение 21)
enum color
{
    red,
    yellow,
    green = 20,
    blue
};
// altitude может быть altitude::high или altitude::low
enum class altitude: char
{
    high = 'h',
    low = 'l', // завершающая запятая разрешена только после CWG 518
}; 
// константа d равна 0, константа e равна 1, константа f равна 3
enum
{
    d,
    e,
    f = e + 2
};
// типы перечислений (как с областью видимости, так и без) могут иметь перегруженные операторы
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);
}
// Перечисление с областью видимости (C++11) может быть частично эмулировано в более ранних версиях C++:
enum struct E11 { x, y }; // начиная с C++11
struct E98 { enum { x, y }; }; // OK в pre-C++11
namespace N98 { enum { x, y }; } // OK в pre-C++11
struct S98 { static const int x = 0, y = 1; }; // OK в pre-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 = красный
a = l
f = 3
C++20 `using enum`: __cpp_using_enum == 201907; x

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также