Enumeration declaration

一个 枚举 是一种独特类型，其值被限制在一定范围内（详见下文），该范围可能包含若干显式命名的常量（" 枚举项 "）。

常量的值是被称为枚举 底层类型 的整数类型的值。枚举具有与其底层类型相同的 大小 、 值表示 和 对齐要求 。此外，枚举的每个值都具有与底层类型对应值相同的表示形式。

枚举通过以下语法（重新）声明：

枚举有两种不同的类型： 无作用域枚举 （使用 enum-key enum 声明）和 有作用域枚举 （使用 enum-key enum class 或 enum struct 声明）。

无作用域枚举

每个 enumerator 都会成为枚举类型的命名常量（即 name ），在封闭作用域中可见，并且可以在需要常量时使用。

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

每个枚举项都与底层类型的一个值相关联。当在 枚举列表 中提供 = 时，枚举项的值由这些关联的 常量表达式 定义。如果第一个枚举项没有 = ，其关联值为零。对于任何其他定义中没有 = 的枚举项，其关联值为前一个枚举项的值加一。

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(); // 正确：'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; // 错误：无法从作用域枚举隐式转换为 int
    int n = static_cast<int>(r); // 正确，n = 21
    std::cout << n << '\n'; // 输出 21
}

enum byte : unsigned char {}; // byte是新型整数类型；另见std::byte (C++17)
byte b{42};        // C++17起合法（直接列表初始化）
byte c = {42};     // 错误
byte d = byte{42}; // C++17起合法；值与b相同
byte e{-1};        // 错误
struct A { byte b; };
A a1 = {{42}};     // 错误（构造函数参数的拷贝列表初始化）
A a2 = {byte{42}}; // C++17起合法
void f(byte);
f({42}); // 错误（函数参数的拷贝列表初始化）
enum class Handle : std::uint32_t { Invalid = 0 };
Handle h{42}; // 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>
// 占用16位的枚举
enum smallenum: std::int16_t
{
    a,
    b,
    c
};
// color 可以是红色（值0）、黄色（值1）、绿色（值20）或蓝色（值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 }; }; // 在 C++11 之前版本中可用
namespace N98 { enum { x, y }; } // 在 C++11 之前版本中可用
struct S98 { static const int x = 0, y = 1; }; // 在 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 = red
a = l
f = 3
C++20 `using enum`: __cpp_using_enum == 201907; x

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

参考文献

参见