枚举声明

枚举（enumeration）是独立的类型，其值限制在一个取值范围内（细节见下文），它可以包含数个明确命名的常量（“枚举项（enumerator）”）。各常量的值是某个整型类型（称为该枚举的底层类型（underlying type））的值。

枚举以下列语法定义：


enum-关键词 attr(可选) enum-名(可选) enum-基(可选)(C++11) `{` 枚举项列表(可选) `}`	(1)

enum-关键字 attr(可选) enum-名 enum-基(可选) `;`	(2)	(C++11 起)

1) enum-说明符，出现于声明语法的声明说明符序列：定义枚举类型与其枚举项。

2) 不可见（opaque）枚举声明：定义枚举类型，但不定义其枚举项：在此声明后，该类型是完整类型，且其大小已知。注意：仅有的在 enum-名之前出现嵌套名说明符的情况，是类模板的有作用域枚举成员的显式特化声明 (C++14 起)

enum-关键字	-	`enum`、`enum class`(C++11 起) 或 `enum struct`(C++11 起) 之一
attr(C++11)	-	任意数量的属性的可选序列
enum-名	-	所声明的枚举的名字。若存在，且若此声明为重声明，则其之前可带有嵌套名说明符(C++11 起)，即名字和作用域解析运算符 `::` 的序列并以作用域解析运算符结尾。仅可在无作用域枚举声明中省略名字
enum-基(C++11)	-	冒号 (`:`)，后随指名某个整型类型的类型说明符序列（若它为 cv 限定，则忽略其限定性），该类型将作为此枚举类型的固定底层类型
枚举项列表	-	枚举项定义的逗号分隔列表，每项要么是简单的标识符，它成为枚举项之名，要么是带初始化器的标识符：标识符 `=` 常量表达式。任一情况下，标识符可直接后随一个可选的属性说明符序列。 (C++17 起)

有两种截然不同的枚举：无作用域枚举（以 enum-关键词 enum 声明）和有作用域枚举（以 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 << "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

无作用域枚举类型的值可隐式转换为整型类型。若底层类型不固定，则其值可转换到以下列表中首个能保有其整个值范围的类型：int、unsigned int、long、unsigned long、long long 或 unsigned long long。若底层类型固定，则其值可转换到其提升后的底层类型。

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

整数、浮点和枚举类型的值，可用 static_cast 或显式转型转换到任何枚举类型。若底层类型不固定，且若源值在范围外（源值在范围内，若它能以足以保有目标枚举的所有枚举项的最小位域表示，这里若源值为浮点类型则首先转换到枚举的底层类型），则其结果未指明 (C++17 前)未定义 (C++17 起)。否则，结果与隐式转换到底层类型的结果相同。

注意，这种转换后的值不必等于任何为该枚举所定义的具名枚举项。

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); // C++17 起为未定义行为
access_t y = static_cast<access_t>(8); // C++17 起为未定义行为
 
enum foo { a = 0, b = UINT_MAX }; // 范围：[0, UINT_MAX]
foo x= foo(-1); // C++17 起为未定义行为，即使 foo 的底层类型为 unsigned int

无作用域枚举的名字可以忽略：这种声明仅将各枚举项引入到其外围作用域中：

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\|class` 名字 `{` 枚举项 `=` 常量表达式 `,` 枚举项 `=` 常量表达式 `,` ... `}`	(1)

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

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

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

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

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

3) 底层类型为 int 的有作用域枚举类型的不可见枚举声明

4) 底层类型为类型的有作用域枚举类型的不可见枚举声明

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

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); // OK, n = 21

(C++11 起)

底层类型固定的有作用域枚举类型和无作用域枚举类型，若下列全部条件为真，则都能用列表初始化从一个整数初始化而无需转型：

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

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

enum byte : unsigned char {}; // byte 是新的整数类型
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 起)

示例

运行此代码

#include <iostream>
 
// 采用 16 位的 enum
enum smallenum: 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', // C++11 允许尾随逗号
}; 
 
// 常量 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);
}
 
int main()
{
    color col = red;
    altitude a;
    a = altitude::low;
 
    std::cout << "col = " << col << '\n'
              << "a = "   << a   << '\n'
              << "f = "   << f   << '\n';
}

输出：

col = red
a = l
f = 3

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR	应用于	出版时的行为	正确行为
CWG 1638	C++14	不可见枚举声明的文法禁止用于模板特化	容许 nested-name-specifier

语言
标准库头文件
自立与有宿主实现
具名要求
语言支持库
概念库 (C++20)
诊断库
工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
输入/输出库
本地化库
正则表达式库 (C++11)
原子操作库 (C++11)
线程支持库 (C++11)
文件系统库 (C++17)
技术规范

枚举声明

无作用域枚举

有作用域枚举

示例

缺陷报告

参阅

导航