枚举声明

枚举是一种独立的类型，它的值被限制在一个取值范围内（细节见下文），它可以包含数个明确命名的常量（“枚举项”）。

各常量的值是某个整数类型（称为该枚举的底层类型）的值。枚举的大小、值表示和对齐要求与它的底层类型相同。而且枚举的每个值都与该枚举的底层类型的对应值有着相同的表示。

以下列语法（重复）声明枚举：


枚举关键词属性 (可选) 枚举头名 (可选) 枚举基 (可选) `{` 枚举项列表 (可选) `}`	(1)

枚举关键词属性 (可选) 枚举头名 (可选) 枚举基 (可选) `{` 枚举项列表 `, }`	(2)

枚举关键词属性 (可选) 枚举头名枚举基 (可选) `;`	(3)	(C++11 起)

1) 枚举说明符，在声明语法的声明说明符序列中出现：定义枚举类型和它的枚举项。

2) 可以在枚举项列表后跟随一个逗号。

3) 笼统枚举声明：定义枚举类型，但不定义它的枚举项：在此声明后，该类型是完整类型，且它的大小已知。

枚举关键字

-

`enum`	(C++11 前)
`enum`、`enum class` 或 `enum struct` 之一	(C++11 起)

属性 - (C++11 起) 任意数量的属性的可选序列

枚举头名

-

所声明的枚举的名字，可以省略。

(C++11 前)

所声明的枚举的名字，并且前面可以有一个嵌套名说明符：即名字和作用域解析运算符 :: 的序列并以作用域解析运算符结尾。只能在非笼统声明的无作用域枚举声明中省略枚举名。
嵌套名说明符只有在枚举名存在且此声明是重声明时才能使用。对于笼统枚举声明，只有在显式特化声明中嵌套名说明符才能在枚举的名字前出现。
如果存在嵌套名说明符，那么枚举说明符 不能指代只是从 using 声明继承或引入的枚举，并且该枚举说明符 只能在先前声明的外围命名空间出现。此时嵌套名说明符不能以 decltype 说明符起始。

(C++11 起)

枚举基 - (C++11 起) 冒号 (:)，后随指名某个整数类型的类型说明符序列（忽略它的限定性），该类型将作为此枚举类型的固定底层类型

枚举项列表 - 枚举项定义的逗号分隔列表，每项要么是简单的独一无二的标识符，它成为枚举项的名字，要么是带常量表达式的独一无二的标识符：标识符 = 常量表达式。在任一情况下，标识符都可以直接后随一个属性说明符序列。 (C++17 起)

有两种截然不同的枚举：无作用域枚举（以枚举关键词 enum 声明）和有作用域枚举（以枚举关键词 enum class 或 enum struct 声明）。

无作用域枚举


`enum` 名字 (可选) `{` 枚举项 `=` 常量表达式 `,` 枚举项 `=` 常量表达式 `,` ... `}`	(1)

`enum` 名字 (可选) `:` 类型 `{` 枚举项 `=` 常量表达式 `,` 枚举项 `=` 常量表达式 `,` ... `}`	(2)	(C++11 起)

`enum` 名字 `:` 类型 `;`	(3)	(C++11 起)

1) 声明一个无作用域枚举类型，它的底层类型不固定（此时底层类型是由实现定义的某个能表示所有枚举项值的整数类型；此类型不大于 int，除非枚举项的值不能放入 int 或 unsigned int。如果枚举项列表为空，那么底层类型是如同枚举拥有单个值为 0 的枚举项。如果不存在能够表示所有枚举项的值的整数类型，那么该枚举非良构）。

2) 声明一个底层类型固定的无作用域枚举类型。

3) 无作用域枚举的笼统枚举声明必须指定名字与底层类型。

每个枚举项都成为该枚举类型（即名字）的一个具名常量，在它的外围作用域可见，且可以用于要求常量的任何位置。

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;
}

每个枚举项都与一个底层类型的值相关联。当枚举项列表中提供了 = 时，各枚举项的值由它们所关联的常量表达式所定义。如果首个枚举项 =，那么它的关联值为零。对于其他任何定义中无 = 的枚举项，它的关联值是前一枚举项加一。

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;

在成员声明的声明说明符中，以下序列

enum 枚举头名 :

只能被解析成枚举声明的一部分：

struct S
{
    enum E1 : int {};
    enum E1 : int {}; // 错误：重声明了枚举，不会被解析成宽度为零且具有类型 enum E1 的位域
};
 
enum E2 { e1 };
 
void f()
{
    false ? new enum E2 : int(); // OK：int 不会被解析成底层类型
}

(C++11 起)

以链接为目的的枚举名

没有以链接为目的的 typedef 名且有枚举项的无名枚举会以链接为目的，通过它的底层类型和它的首个枚举项指名；这种枚举被视为以它的枚举项以链接为目的具有枚举名。

有作用域枚举


`enum struct\|class` 名字 `{` 枚举项 `=` 常量表达式 `,` 枚举项 `=` 常量表达式 `,` ... `}`	(1)

`enum struct\|class` 名字 `:` 类型 `{` 枚举项 `=` 常量表达式 `,` 枚举项 `=` 常量表达式 `,` ... `}`	(2)

`enum struct\|class` 名字 `;`	(3)

`enum struct\|class` 名字 `:` 类型 `;`	(4)

1) 声明底层类型为 int 的有作用域枚举类型（关键词 class 与 struct 完全等价）

2) 声明底层类型为类型的有作用域枚举类型

3) 底层类型为 int 的有作用域枚举类型的笼统枚举声明

4) 底层类型为类型的有作用域枚举类型的笼统枚举声明

每个枚举项都成为该枚举的类型（即名字）的具名常量，它被该枚举的作用域所包含，且可用作用域解析运算符访问。没有从有作用域枚举项到整数类型的隐式转换，尽管 static_cast 可以用来获得枚举项的数值。

运行此代码

#include <iostream>
 
int main()
{
    enum class Color { red, green = 20, blue };
    Color r = Color::blue;
 
    switch(r)
    {
        case Color::red  : std::cout << "红\n"; break;
        case Color::green: std::cout << "绿\n"; break;
        case Color::blue : std::cout << "蓝\n"; break;
    }
 
    // int n = r; // 错误：不存在从有作用域枚举到 int 的隐式转换
    int n = static_cast<int>(r); // OK, n = 21
    std::cout << n << '\n'; // prints 21
}

(C++11 起)

枚举在满足下列条件时都能用列表初始化从一个整数初始化而无需转型：

初始化是直接列表初始化
初始化器列表仅有单个元素
枚举是底层类型固定的有作用域枚举或无作用域枚举
转换是非窄化转换

这使得我们能引入新的整数类型（例如 SafeInt）并享受与它的底层整数类型相同的既存调用约定，即使 ABI 不利于以值传递/返回结构体。

enum byte : unsigned char {}; // byte 是新的整数类型；参见 std::byte（C++17）
byte b{42};        // C++17 起 OK（直接列表初始化）
byte c = {42};     // 错误
byte d = byte{42}; // C++17 起 OK；与 b 的值相同
byte e{-1};        // 错误
 
struct A { byte b; };
A a1 = {{42}};     // 错误（构造函数形参的复制列表初始化）
A a2 = {byte{42}}; // C++17 起 OK
 
void f(byte);
f({42}); // 错误（函数形参的复制列表初始化）
 
enum class Handle : std::uint32_t { Invalid = 0 };
Handle h{42}; // C++17 起 OK

(C++17 起)

using enum 声明


`using enum` 声明符 `;`		(C++20 起)

声明符

-

（可有限定的）标识符或简单模板标识

其中声明符必须指名一个非待决枚举类型。枚举类型的查找会根据声明符是否有限定而进行只查找类型的常规有限定或无限定查找。

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
}

using enum 声明引入它所指名的枚举的枚举项名字，如同用对每个枚举项的 using 声明。在类作用域中时，using enum 声明将它指名的枚举的枚举项名字作为成员添加到作用域，使成员查找能访问它们。

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
}

引入两个同名的枚举项的两个 using enum 声明会冲突。

enum class fruit { orange, apple };
enum class color { red, orange };
 
void f()
{
    using enum fruit;    // OK
    // using enum color; // 错误：color::orange 与 fruit::orange 冲突
}

(C++20 起)

注解

无作用域枚举类型的值可以被提升或转换为整数类型：

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

功能特性测试宏	值	标准	功能特性
`__cpp_enumerator_attributes`	201411L	(C++17)	应用到枚举项的属性
`__cpp_using_enum`	201907L	(C++20)	using enum

关键词

enum, struct, class, using

示例

运行此代码

#include <cstdint>
#include <iostream>
 
// 采用 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 << "红"; break;
        case yellow: os << "黄"; break;
        case green : os << "绿"; break;
        case blue  : os << "蓝"; 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 前也 OK
 
namespace N98 { enum { x, y }; } // C++11 前也 OK
 
struct S98 { static const int x = 0, y = 1; }; // C++11 前也 OK
 
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++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
CWG 377	C++98	未指定当不存在能够表示所有枚举项的值的整数类型时的行为	此时枚举非良构
CWG 518	C++98	枚举项列表不能后随逗号	可以后随一个逗号
CWG 1514	C++11	底层类型固定的枚举的重声明可能会在类成员声明中被解析成位域	只能被解析成重声明
CWG 1638	C++11	不可见枚举声明的文法禁止用于模板特化	容许嵌套类型说明符
CWG 1766	C++98	从范围外的值转型到无固定底层类型的枚举拥有未指明的结果	行为未定义
CWG 1966	C++11	CWG 问题 1514 的解决方案导致条件表达式中的 `:` 也会成为枚举基的一部分	只将该解决方案应用到成员声明说明符中
CWG 2156	C++11	枚举定义可以通过 using 声明来定义枚举类型	已禁止
CWG 2157	C++11	CWG 问题 1966 的解决方案没有覆盖到有限定的枚举名	已覆盖
CWG 2530	C++98	枚举项列表可以包含多个标识符相同的枚举项	已禁止
CWG 2590	C++98	枚举的大小，值表示和对齐要求与它的底层类型无关	与底层类型的对应属性相同
CWG 2621	C++20	不明确 using enum 声明如何查找枚举声明	使之明确
CWG 2877	C++20	在 using enum 声明中会查找非类型声明	不会查找非类型声明

参阅

C++23 标准（ISO/IEC 14882:2024）：

9.7.1 Enumeration declarations [dcl.enum]

C++20 标准（ISO/IEC 14882:2020）：

9.7.1 Enumeration declarations [dcl.enum]

C++17 标准（ISO/IEC 14882:2017）：

10.2 Enumeration declarations [dcl.enum]

C++14 标准（ISO/IEC 14882:2014）：

7.2 Enumeration declarations [dcl.enum]

C++11 标准（ISO/IEC 14882:2011）：

7.2 Enumeration declarations [dcl.enum]

C++03 标准（ISO/IEC 14882:2003）：

7.2 Enumeration declarations [dcl.enum]

C++98 标准（ISO/IEC 14882:1998）：

7.2 Enumeration declarations [dcl.enum]

参阅

is_enum (C++11)	检查类型是否是枚举类型 (类模板)
is_scoped_enum (C++23)	检查类型是否为有作用域枚举类型 (类模板)
underlying_type (C++11)	获取给定枚举类型的底层整数类型 (类模板)
to_underlying (C++23)	转换枚举为其底层类型 (函数模板)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

枚举声明

无作用域枚举

以链接为目的的枚举名

有作用域枚举

using enum 声明

注解

关键词

示例

缺陷报告

参阅

参阅

导航