C++中不使用命名空间实现嵌套枚举的可行方案？

我来给你几个符合需求的方案，都是不需要命名空间或者类层次结构的，而且能作为类成员类型使用：

这种方式完全实现了你想要的EXP_TYPE::BINARY::PLUS风格的赋值，同时可以作为类成员类型：

首先定义包含嵌套枚举的结构体：

#include <variant>

struct ExpType {
    // 二元运算符枚举
    enum class Binary {
        PLUS, MINUS, MULTIPLY, DIV
    };

    // 一元运算符枚举
    enum class Unary {
        PLUS, MINUS, POINTER, INC
    };
};

然后在你的expression类中，用std::variant来存储运算符类型（variant可以容纳不同类型的枚举值）：

class Expression {
public:
    Expression* right_exp = nullptr;
    Expression* left_exp = nullptr;
    // 用variant存储二元或一元运算符类型
    std::variant<ExpType::Binary, ExpType::Unary> type;

    // 可以提供构造函数简化初始化
    explicit Expression(ExpType::Binary bin_op) : type(bin_op) {}
    explicit Expression(ExpType::Unary un_op) : type(un_op) {}
};

使用示例： #

// 初始化一个二元加法表达式
Expression add_exp(ExpType::Binary::PLUS);
// 修改为一元减法
add_exp.type = ExpType::Unary::MINUS;

// 判断运算符类型并处理
if (auto bin_op = std::get_if<ExpType::Binary>(&add_exp.type)) {
    switch (*bin_op) {
        case ExpType::Binary::PLUS:
            // 处理二元加法逻辑
            break;
        case ExpType::Binary::MINUS:
            // 处理二元减法逻辑
            break;
        // 其他二元运算符
    }
} else if (auto un_op = std::get_if<ExpType::Unary>(&add_exp.type)) {
    switch (*un_op) {
        case ExpType::Unary::MINUS:
            // 处理一元减法逻辑
            break;
        case ExpType::Unary::POINTER:
            // 处理指针运算符逻辑
            break;
        // 其他一元运算符
    }
}

优点： #

• 完全符合你想要的ExpType::Binary::PLUS嵌套语法
• 强类型安全，二元和一元运算符不会被混淆
• 不需要额外的类层次结构或命名空间作为类成员

缺点： #

• 需要C++17及以上支持（因为用到了std::variant）
• 判断运算符类型时需要用std::get_if或std::visit，稍微增加一点代码复杂度

如果你可以接受稍微调整语法（不用嵌套的::BINARY::），这个方案最简洁，代码量最少：

enum class ExpType {
    // 二元运算符，用Binary前缀区分
    BinaryPlus, BinaryMinus, BinaryMultiply, BinaryDiv,
    // 一元运算符，用Unary前缀区分
    UnaryPlus, UnaryMinus, UnaryPointer, UnaryInc
};

class Expression {
public:
    Expression* right_exp = nullptr;
    Expression* left_exp = nullptr;
    ExpType type;

    explicit Expression(ExpType op) : type(op) {}
};

使用示例： #

Expression exp1(ExpType::BinaryPlus);
exp1.type = ExpType::UnaryMinus;

// 直接比较判断
if (exp1.type == ExpType::BinaryPlus) {
    // 处理二元加法
} else if (exp1.type == ExpType::UnaryMinus) {
    // 处理一元减法
}

优点： #

• 语法简单，赋值和比较都直接明了
• 不需要额外依赖（兼容C++11及以上）
• 代码逻辑清晰，维护成本低

缺点： #

• 没有嵌套的命名结构，需要用前缀区分一元/二元运算符

这个方案和方案2类似，但保留了运算符的短名称，通过辅助函数区分一元/二元类型：

enum class ExpType {
    // 二元运算符
    PLUS, MINUS, MULTIPLY, DIV,
    // 一元运算符（用U_前缀避免同名冲突）
    U_PLUS, U_MINUS, POINTER, INC
};

// 辅助函数：判断是否为二元运算符
bool is_binary(ExpType op) {
    switch(op) {
        case ExpType::PLUS:
        case ExpType::MINUS:
        case ExpType::MULTIPLY:
        case ExpType::DIV:
            return true;
        default:
            return false;
    }
}

// 辅助函数：判断是否为一元运算符
bool is_unary(ExpType op) {
    return !is_binary(op);
}

class Expression {
public:
    Expression* right_exp = nullptr;
    Expression* left_exp = nullptr;
    ExpType type;

    explicit Expression(ExpType op) : type(op) {}
};

使用示例： #

Expression exp1(ExpType::PLUS);
exp1.type = ExpType::U_MINUS;

if (is_binary(exp1.type)) {
    switch(exp1.type) {
        case ExpType::PLUS:
            // 二元加法逻辑
            break;
    }
} else if (is_unary(exp1.type)) {
    switch(exp1.type) {
        case ExpType::U_MINUS:
            // 一元减法逻辑
            break;
    }
}

优点： #

• 运算符名称简短，代码可读性好
• 用辅助函数清晰区分一元/二元类型
• 兼容C++11及以上，实现简单

缺点： #

• 同名运算符（比如PLUS和U_PLUS）需要手动加前缀避免冲突

内容的提问来源于stack exchange，提问作者Murilo Maestro