enum class：更安全的枚举类型

// a.h
enum Color { Red, Green, Blue };

// b.h
enum TrafficLight { Red, Yellow, Green }; // 咦？🤔

// some.cpp
#include "a.h"
#include "b.h" // 💥 编译失败... Red 和 Green 被重定义了

// 模块A: 定义颜色
enum Color {
    Red,
    Green,
    Blue
};

// 模块B: 定义交通信号灯
enum TrafficLight {
    Red,     // 💥 编译失败：'Red' 这个名字已经被占用了
    Yellow,
    Green    // 💥 'Green' 也一样
};

enum Color { Red, Green, Blue };
enum Animal { Dog, Cat, Bird };

Color myColor = Blue; // myColor 的值是 2
Animal myPet = Dog;   // myPet 的值是 0

// 编译器对此睁一只眼闭一只眼，它认为这是合法的(2 == 0)
// 但有经验的程序员都知道，这种“合法”的背后，可能藏着一个深夜加班的陷阱 🕸️。
if (myColor == myPet) {
    // ...
}

void paint(int colorCode);
paint(myColor); // ✅ 也能编译通过。但 paint 函数的作者可能希望得到一个 Color 类型，
                // 而不是一个普通的整数，类型的上下文信息在这里丢失了。

// player.h
class Player {
public:
    // 我们希望在这里使用 WeaponType，但又不想为了一个类型声明
    // 就完整地 #include "weapon.h"，因为它可能很庞大，或引入其他依赖。
    void equip(WeaponType type); // ❌ 编译失败，WeaponType 是什么？编译器不认识它
private:
    WeaponType currentWeapon;
};

struct Color {
    enum Type { Red, Green, Blue };
};

struct TrafficLight {
    enum Type { Red, Yellow, Green };
};

// 使用时，必须指明出处，问题解决。
Color::Type c = Color::Red;
TrafficLight::Type t = TrafficLight::Red; // ✅ 不再冲突

#include <boost/core/scoped_enum.hpp>

// 🪄 使用Boost宏来声明一个“作用域枚举”
BOOST_SCOPED_ENUM_DECLARE_BEGIN(FileAccess)
{
    Read,
    Write,
    ReadWrite
}
BOOST_SCOPED_ENUM_DECLARE_END(FileAccess)

void check_access(FileAccess permission) {
    // 1. ✅ 作用域限制住了，必须通过类型名访问
    FileAccess p = FileAccess::Read; // 正确
    // p = Write;                    // ❌ 编译失败，'Write'不在全局作用域中

    // 2. ✅ 类型变安全了，不能随便变成整数
    // if (p == 0)                   // ❌ 编译失败，无法与整数比较
    if (p == FileAccess::Read) {     // 正确，只能与同类型比较
        // ...
    }
}

// 🧐 BOOST_SCOPED_ENUM 宏展开后的概念性代码
struct FileAccess
{
    // 1. 🏠 把真正的 enum 定义在 struct 内部，作为内嵌类型。
    //    这就天然地创建了一个作用域，外面的代码必须通过 FileAccess::来访问。
    enum internal_type {
        Read,
        Write,
        ReadWrite
    };

private:
    // 2. 🤫 struct 内部有一个私有成员，用来存放真实的枚举值。
    internal_type m_value;

public:
    // 3. 🚪 提供一个公有的构造函数，让我们可以从内部枚举值创建出一个 FileAccess 对象。
    //    比如 FileAccess p = FileAccess::Read; 就是通过这个构造函数完成的。
    constexpr FileAccess(internal_type value) : m_value(value) {}

    // 4. 🤝 重载比较运算符，让同类型的对象可以互相比较。
    constexpr bool operator==(FileAccess other) const {
        return m_value == other.m_value;
    }
    // ... 其他比较运算符 ...

    // 5. 🚫 最关键的：不提供 operator int() const 这样的类型转换函数。
    //    这就堵死了隐式转换为整数的路，保证了类型安全。

    // 6. 🗝️ 为 switch 语句留一个“后门”
    friend constexpr int native_value(FileAccess e) {
        return e.m_value;
    }
};

void process_permission(FileAccess p) {
    switch (p) { // ❌ 编译失败！switch 的参数必须是整数类型或能隐式转为整数的类型
        // ...
    }
}

void process_permission(FileAccess p) {
    // 使用 native_value() 这个“钥匙”🔑 取出内部的整数值
    switch (boost::native_value(p)) {
        // case 标签里可以直接使用内部枚举值，因为它们是常量表达式
        case FileAccess::Read:
            // 处理读权限
            break;
        case FileAccess::Write:
            // 处理写权限
            break;
        // ...
    }
}

// 假设有这样一个枚举
enum class Status { Connecting, Connected, Disconnected };

Status current_status = Status::Connecting;
qDebug() << "Current status:" << current_status;

// 输出: Current status: 0
// 😵 看到这个 '0'，我们的大脑需要多转一个弯：'0' 是什么来着？哦，是 Connecting。

#include <QObject>
#include <QMetaEnum>
#include <QDebug>

class Connection : public QObject {
    Q_OBJECT // 必须有这个宏，它是元对象系统的入口 🚪
public:
    enum class Status { Connecting, Connected, Disconnected };

    // 📝 使用 Q_ENUM 将 Status “登记”到 Connection 的元信息中
    Q_ENUM(Status)
};

// --- 在其他地方使用 ---
// 假设我们有一个 Connection 实例
Connection conn;
// 为了让 qDebug 能够正确地将枚举转换为字符串，我们需要从 QMetaEnum 获取这些信息
// (注意：实际应用中，如果 Connection::Status 在 QVariant 中使用或通过信号槽传递，转换通常是自动的)
qDebug() << "Current status:" << QMetaEnum::fromType<Connection::Status>().valueToKey(static_cast<int>(Connection::Status::Connecting));

// 在许多现代 Qt 集成中，如果类型已注册，qDebug 甚至可能直接工作：
qDebug() << "Current status:" << Connection::Status::Connecting;
// 理想输出: Current status: Connection::Status(Connecting)

// 🧙‍♂️ moc 工具生成的概念性代码
// 1. 🏗️ moc 为 Connection 类生成了一个静态的元对象(meta-object)实例
const QMetaObject Connection::staticMetaObject = {
    // ... 其他元信息 ...

    // 2. 📜 它将 Q_ENUM 中的信息，转换成一个字符串数组
    //    这个数组包含了枚举的名字、值的名字和值的整数表示。
    qt_meta_stringdata_Connection_t::data,

    // 3. 🔗 还有一些函数指针，用来在运行时创建 QMetaEnum 等对象。
    qt_meta_data_Connection,
    // ...
};

// 4. 🗂️ 这就是那个包含所有名字的字符串数据
static const qt_meta_stringdata_Connection_t qt_meta_stringdata_Connection = {
    "Connection\0Status\0Connecting\0Connected\0Disconnected\0"
    // ...
};

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green }; // ✅ 各自安好，互不打扰

// 必须通过类型名来访问，像是在访问一个命名空间下的成员
Color c = Color::Red; // 正确
// Color c = Red;     // ❌ 编译失败，Red 不在全局作用域中

enum class Color { Red, Green, Blue };

Color myColor = Color::Red;

// if (myColor == 0) // ❌ 编译失败，Color 类型不能和整数直接比较
if (myColor == Color::Red) {} // ✅ 正确，只能和同类型的枚举值比较

// int colorCode = myColor; // ❌ 编译失败，不能隐式地把 Color 当成整数
                          //    这保护了我们，防止了类型信息的丢失。

// 如果你确实需要那个整数值，必须明确地告诉编译器你的意图。
int colorCode = static_cast<int>(myColor); // ✅ “我确定，我就是要它对应的整数值”

// a.h
#include <cstdint>
// 我们可以明确告诉编译器：WeaponType 本质上是一个 uint8_t。
// 编译器知道了它的大小，因此就允许我们只声明，不定义。
enum class WeaponType : std::uint8_t;

class Player {
public:
    // ✅ 编译通过，player.h 无需知道 WeaponType 的所有具体值，
    //    大大降低了头文件依赖。
    void equip(WeaponType type);
private:
    WeaponType currentWeapon;
};

// weapon.h
#include <cstdint>
// 在源文件中提供完整的定义
enum class WeaponType : std::uint8_t {
    Sword,  // 🗡️
    Axe,    // 🪓
    Bow     // 🏹
};

// 假设 Direction 已经定义
// enum class Direction { North, South, East, West };
void navigate(Direction current) {
    switch (current) {
        // 每个 case 都必须使用完整的类型名，更加清晰
        case Direction::North: // ⬆️
            // ...
            break;
        case Direction::South: // ⬇️
            // ...
            break;
        // ...
    }
}

enum class Permission : std::uint8_t {
    None    = 0,
    Read    = 1 << 0, // 📖 值为 1
    Write   = 1 << 1, // ✍️ 值为 2
    Execute = 1 << 2  // 🏃 值为 4
};

// 我们可以通过重载运算符来“教会”Permission如何进行位运算
inline constexpr Permission operator|(Permission a, Permission b) {
    // 1. 获取 Permission 底层的整数类型 (这里是 std::uint8_t)
    using T = std::underlying_type_t<Permission>;
    // 2. 把 a 和 b 都转换为它们底层的整数
    // 3. 对整数进行按位或 | 运算
    // 4. 把结果再转换回 Permission 类型
    return static_cast<Permission>(static_cast<T>(a) | static_cast<T>(b));
}
// ... 其他位运算符的重载 ...

// 然后就可以像这样使用了
Permission p = Permission::Read | Permission::Write; // 赋予读和写的权限

// 状态机 🤖
enum class PlayerState { Idle, Walking, Running, Jumping };
void set_player_state(PlayerState new_state);

// API 设计 🎨
enum class ImageFormat { PNG, JPEG, BMP };
bool save_image(const std::string& path, ImageFormat format);

// 假设有 LogLevel 枚举
// enum class LogLevel { Debug, Info, Warning, Error };
std::string to_string(LogLevel level) {
    switch (level) {
        case LogLevel::Debug:   return "🐛 Debug";
        case LogLevel::Info:    return "ℹ️ Info";
        case LogLevel::Warning: return "⚠️ Warning";
        case LogLevel::Error:   return "🔥 Error";
        default:                return "❓ Unknown";
    }
}

// ...
// qDebug() << "Log level set to:" << to_string(current_level);