枚举类型

定义与作用

枚举用于定义一组具名的整型常量，提升代码可读性和类型安全性。C++ 提供两种枚举：

类型	引入版本	特点
`enum`（传统枚举）	C++98	值隐式转换为 int，标识符泄漏到外层作用域
`enum class`（限定作用域枚举）	C++11	强类型、作用域限定、不隐式转换为 int

使用场景：状态机、错误码、配置选项、星期/月份等离散值集合。

核心原理

传统 enum vs enum class 对比

底层类型指定

完整示例

示例一：HTTP 状态码处理——传统枚举的困境

场景说明：用传统 enum 和 enum class 分别实现 HTTP 状态码分类，展示后者的类型安全优势。

#include <iostream>
#include <string>
#include <cstdint>

// 传统枚举：值泄漏到外层作用域
enum HttpStatusOld {
    OK_OLD = 200,
    NOT_FOUND_OLD = 404,
    SERVER_ERROR_OLD = 500
};

// 其他枚举可能冲突
enum FileStatus {
    OK_FILE = 0,    // 与 HttpStatusOld::OK_OLD 命名不同，勉强能区分
    NOT_FOUND_FILE = -1
};

// enum class：限定作用域 + 强类型
enum class HttpStatus : uint16_t {
    OK = 200,
    Created = 201,
    MovedPermanently = 301,
    BadRequest = 400,
    Unauthorized = 401,
    NotFound = 404,
    InternalServerError = 500
};

// 另一个 enum class，名称可以相同
enum class DatabaseError : uint8_t {
    OK = 0,           // 与 HttpStatus::OK 不冲突
    NotFound = 1,     // 与 HttpStatus::NotFound 不冲突
    ConnectionFailed = 2,
    Timeout = 3
};

std::string status_text(HttpStatus status) {
    switch (status) {
        case HttpStatus::OK:                  return "请求成功";
        case HttpStatus::Created:             return "已创建";
        case HttpStatus::MovedPermanently:    return "永久重定向";
        case HttpStatus::BadRequest:          return "请求错误";
        case HttpStatus::Unauthorized:        return "未授权";
        case HttpStatus::NotFound:            return "未找到";
        case HttpStatus::InternalServerError: return "服务器内部错误";
        default:                              return "未知状态";
    }
}

bool is_client_error(HttpStatus status) {
    auto code = static_cast<uint16_t>(status);
    return code >= 400 && code < 500;
}

int main() {
    // ---- 传统枚举的问题 ----
    int old_status = OK_OLD;         // 隐式转换为 int，丢失类型信息
    old_status = 999;                // 可以赋任意值，没有类型检查
    std::cout << "传统枚举: " << old_status << std::endl;

    // ---- enum class 的使用 ----
    HttpStatus status = HttpStatus::OK;

    // int x = status;               // 编译错误：不能隐式转换
    int code = static_cast<int>(status); // 必须显式转换

    std::cout << "\n===== HTTP 响应 =====" << std::endl;
    std::cout << "状态: " << status_text(status)
              << " (" << code << ")" << std::endl;

    // 遍历多个状态
    std::vector<HttpStatus> responses = {
        HttpStatus::OK,
        HttpStatus::NotFound,
        HttpStatus::InternalServerError,
        HttpStatus::Unauthorized
    };

    for (auto s : responses) {
        std::cout << "  " << static_cast<int>(s) << ": "
                  << status_text(s);
        if (is_client_error(s)) {
            std::cout << " [客户端错误]";
        }
        std::cout << std::endl;
    }

    // ---- 不同枚举类型不可混用 ----
    DatabaseError db_err = DatabaseError::NotFound;
    // if (db_err == HttpStatus::NotFound) {} // 编译错误：不同类型

    std::cout << "\n数据库错误码: " << static_cast<int>(db_err) << std::endl;

    return 0;
}

预期输出：

传统枚举: 999

===== HTTP 响应 =====
状态: 请求成功 (200)
  200: 请求成功
  404: 未找到 [客户端错误]
  500: 服务器内部错误
  401: 未授权 [客户端错误]

数据库错误码: 1

逐段分析：

传统 enum HttpStatusOld 的值可以直接赋给 int，也能把任意整数赋给枚举变量——类型不安全
OK_OLD 和 OK_FILE 需要不同命名来避免冲突，因为传统枚举的值会泄漏到外层作用域
enum class HttpStatus 的值需要通过 HttpStatus::OK 访问，不同枚举可以有同名值
不同类型枚举之间不能比较（db_err == HttpStatus::NotFound 编译失败）
显式转换 static_cast<int>(status) 明确表达了"我知道自己在做什么"的意图

示例二：状态机 + 底层类型指定

场景说明：TCP 连接状态机，使用 enum class 搭配 uint8_t 底层类型减少内存占用。

#include <iostream>
#include <string>
#include <cstdint>

// 指定底层类型为 uint8_t：每个状态只占 1 字节
enum class TcpState : uint8_t {
    Closed = 0,
    Listen,
    SynSent,
    SynReceived,
    Established,
    FinWait1,
    FinWait2,
    CloseWait,
    Closing,
    LastAck,
    TimeWait
};

std::string state_name(TcpState s) {
    switch (s) {
        case TcpState::Closed:       return "CLOSED";
        case TcpState::Listen:       return "LISTEN";
        case TcpState::SynSent:      return "SYN_SENT";
        case TcpState::SynReceived:  return "SYN_RECEIVED";
        case TcpState::Established:  return "ESTABLISHED";
        case TcpState::FinWait1:     return "FIN_WAIT_1";
        case TcpState::FinWait2:     return "FIN_WAIT_2";
        case TcpState::CloseWait:    return "CLOSE_WAIT";
        case TcpState::Closing:      return "CLOSING";
        case TcpState::LastAck:      return "LAST_ACK";
        case TcpState::TimeWait:     return "TIME_WAIT";
        default:                     return "UNKNOWN";
    }
}

class TcpConnection {
public:
    TcpConnection() : state_(TcpState::Closed) {}

    void open() {
        if (state_ == TcpState::Closed) {
            transition(TcpState::SynSent);
        }
    }

    void receive_syn_ack() {
        if (state_ == TcpState::SynSent) {
            transition(TcpState::Established);
        }
    }

    void close() {
        if (state_ == TcpState::Established) {
            transition(TcpState::FinWait1);
        }
    }

    TcpState state() const { return state_; }

private:
    TcpState state_;

    void transition(TcpState new_state) {
        std::cout << "  " << state_name(state_)
                  << " → " << state_name(new_state) << std::endl;
        state_ = new_state;
    }
};

int main() {
    TcpConnection conn;

    std::cout << "=== TCP 连接状态机 ===" << std::endl;
    std::cout << "初始状态: " << state_name(conn.state()) << std::endl;

    conn.open();
    conn.receive_syn_ack();

    std::cout << "当前状态: " << state_name(conn.state()) << std::endl;

    conn.close();

    // 确认内存占用
    std::cout << "\nsizeof(TcpState) = " << sizeof(TcpState)
              << " 字节 (uint8_t 底层类型)" << std::endl;
    std::cout << "sizeof(TcpConnection) = " << sizeof(TcpConnection)
              << " 字节" << std::endl;

    return 0;
}

预期输出：

=== TCP 连接状态机 ===
初始状态: CLOSED
  CLOSED → SYN_SENT
  SYN_SENT → ESTABLISHED
当前状态: ESTABLISHED
  ESTABLISHED → FIN_WAIT_1

sizeof(TcpState) = 1 字节 (uint8_t 底层类型)
sizeof(TcpConnection) = 1 字节

逐段分析：

enum class TcpState : uint8_t 指定底层类型为 uint8_t，保证枚举变量只占 1 字节
状态转换在 transition 函数中统一处理并输出日志
switch 中每个 case 都写完整 TcpState:: 前缀——这是 enum class 的代价（代码更长），但换来类型安全
在嵌入式或网络协议实现中，enum class + 底层类型指定能精确控制内存布局

易错场景与面试考点

易错场景

场景	错误表现	正确做法
传统 `enum` 值隐式转为 int	类型信息丢失，可赋值任意整数	使用 `enum class`
不同枚举类型的值混用	逻辑错误，编译器不报错	`enum class` 禁止跨类型比较
`enum class` 的 switch 漏写作用域前缀	`case OK:` 编译失败	必须写 `case Color::OK:`
忘记指定底层类型导致内存浪费	结构体大小不可控	明确指定 `: uint8_t` 等
传统 `enum` 前向声明	C++98 不允许，C++11 需要指定底层类型	`enum class` 默认支持前向声明

常见面试问题

enum 和 enum class 的核心区别？何时用哪个？——前者值隐式转 int、作用域泄漏、类型不安全；后者强类型、作用域限定、不隐式转换。新代码统一用 enum class。
为什么 enum class 的值不能隐式转换为 int？——这是设计目标：防止意外将枚举值当作整数使用（如算术运算、不同枚举混用），强制程序员显式写出转换意图。
C++11 中 enum class 的底层类型如何指定？有什么好处？——enum class E : uint8_t {}; 指定底层类型。好处：控制内存占用（尤其嵌入式）、支持前向声明、明确取值范围。
如何遍历 enum class 的所有值？——C++ 没有内置反射机制。通常需要手动定义范围常量或使用第三方库（如 magic_enum）。或者定义 First 和 Last 哨兵值配合循环。
传统 enum 为什么容易造成命名污染？——枚举值被注入到枚举所在的作用域，不同枚举不能有同名值。enum class 的值必须通过类型名限定访问，解决了这一问题。

小结

新代码统一使用 enum class，传统 enum 仅用于兼容旧代码
enum class 提供强类型检查、作用域限定、不隐式转换为 int
建议指定底层类型（如 : uint8_t），控制内存占用
需要整数运算时显式 static_cast
不同 enum class 可以有同名值，互不干扰