枚举声明

来自cppreference.com
< cpp‎ | language

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

枚举以下列语法定义:

枚举关键词 属性(可选) 枚举名(可选) 枚举基(可选) { 枚举项列表(可选) } (1)
枚举关键词 属性(可选) 枚举名 枚举基(可选) ; (2) (C++11 起)
1) 枚举说明符,出现于声明语法的 声明说明符序列 :定义枚举类型与其枚举项。
2) 不可见(opaque)枚举声明:定义枚举类型,但不定义其枚举项:在此声明后,该类型是完整类型,且其大小已知。注意:仅有的在 枚举名 之前出现 嵌套名说明符 的情况,是类模板的有作用域枚举成员的显式特化声明}}。
枚举关键字 -

enum

(C++11 前)

enumenum classenum struct 之一

(C++11 起)
属性 - (C++11 起) 可选的任意数量的属性序列
枚举名 - 所声明的枚举的名字。

只能在非不可见的无作用域枚举声明中省略名字。如果名字存在且此声明是重声明,那么它前面可以带有 嵌套名说明符,即名字和作用域解析运算符 :: 的序列并以作用域解析运算符结尾。

(C++11 起)
枚举基 - (C++11 起) 冒号 (:),后随指名某个整型类型的 类型说明符序列(忽略其限定性),该类型将作为此枚举类型的固定底层类型
枚举项列表 - 枚举项定义的逗号分隔列表,每项要么是简单的 标识符,它成为枚举项的名字,要么是带初始化器的标识符:标识符 = 常量表达式在任一情况下,标识符 可直接后随一个可选的属性说明符序列 (C++17 起)

有两种截然不同的枚举:无作用域枚举(以 枚举关键词 enum 声明)和有作用域枚举(以 枚举关键词 enum classenum struct 声明)。

无作用域枚举

enum 名字(可选) { 枚举项 = 常量表达式 , 枚举项 = 常量表达式 , ... } (1)
enum 名字(可选) : 类型 { 枚举项 = 常量表达式 , 枚举项 = 常量表达式 , ... } (2) (C++11 起)
enum 名字 : 类型 ; (3) (C++11 起)
1) 声明一个无作用域枚举类型,其底层类型不固定(此时底层类型是由实现定义的某个能表示所有枚举项值的整型类型;此类型不大于 int,除非枚举项的值不能放入 intunsigned 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

无作用域枚举类型的值可隐式转换为整型类型。如果底层类型不固定,那么该值可转换到下列首个能保有其整个值范围的类型:intunsigned intlongunsigned longlong longunsigned long long、拥有更高转换等级的扩展整数类型(按转换等级顺序,有符号优先于无符号) (C++11 起)。如果底层类型固定,那么该值可转换到其提升后的底层类型(在重载决议中优先),之后它能被提升

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); // CWG1766 起是未定义行为
access_t y = static_cast<access_t>(8);   // CWG1766 起是未定义行为
 
enum foo { a = 0, b = UINT_MAX }; // 范围:[0, UINT_MAX]
foo x= foo(-1); // CWG1766 起是未定义行为,即使 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 的有作用域枚举类型(关键词 classstruct 完全等价)
2) 声明底层类型为 类型 的有作用域枚举类型
3) 底层类型为 int 的有作用域枚举类型的不可见枚举声明
4) 底层类型为 类型 的有作用域枚举类型的不可见枚举声明

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

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
(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 起)

using enum 声明

using enum 嵌套名说明符(可选) 名字 ; (C++20 起)

其中 嵌套名说明符(可选) 名字 不得指名待决类型且必须指名一个枚举类型。

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 起)

注解

尽管从范围外的值转换到无固定底层类型的枚举由 CWG 问题 1766 设为未定义行为,目前没有编译器在常量求值中对它进行要求的诊断。

示例

#include <iostream>
#include <cstdint>
 
// 采用 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', // 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);
}
 
// 有作用域枚举(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 = red
a = l
f = 3
C++20 using enum: __cpp_using_enum == 201907; x

缺陷报告

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

DR 应用于 出版时的行为 正确行为
CWG 1638 C++11 不可见枚举声明的文法禁止用于模板特化 容许嵌套类型说明符
CWG 1766 C++98 从范围外的值转型到无固定底层类型的枚举拥有未指明的结果 行为未定义

参阅

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