C++像枚举头编译器错误一样的Java

Question

有人可以帮助解决以下编译器错误吗？ 我正在尝试在C++中创建类似Java的枚举，并且在Visual Studio 2015中遇到编译器错误。

我使用这些像枚举类这样的Java作为结构的成员，我希望sizeof（MessageType）与Value类型相同。 我知道这将需要我从类中删除 mValueStr 成员，但是我将无法从字符串中查找值。 关于我如何实现这一目标的任何建议将不胜感激。

Java 枚举中真正巧妙的事情之一是能够使用 String 名称或值查找枚举类型。 为此，我在枚举类中添加了 2 个方法，以从这些字符串或值中反向查找枚举。 不幸的是，下面的方法指示了波浪线

static MessageType valueOf(const int& rVal) {
    for (const auto& next : getValues()) {
        if (next == rVal) {
                 ~~
            return next;
        }
    }
    throw std::invalid_argument(
        "Illegal Argument: " + rVal);
}

编译器抱怨如下，我无法完全弄清楚：

1>c:maindlmucaclientudpclientcmc.h(123): error C2678: binary '==': no operator found which takes a left-hand operand of type 'const MessageType' (or there is no acceptable conversion)
1>  c:maindlmucaclientudpclientcmc.h(123): note: could be 'built-in C++ operator==(MessageType::Value, int)'
1>  c:maindlmucaclientudpclientcmc.h(123): note: while trying to match the argument list '(const MessageType, const int)'
1>  UDPClient.cpp
1>c:maindlmucaclientudpclientcmc.h(123): error C2678: binary '==': no operator found which takes a left-hand operand of type 'const MessageType' (or there is no acceptable conversion)
1>  c:program files (x86)windows kits8.1includesharedguiddef.h(192): note: could be 'bool operator ==(const GUID &,const GUID &)'
1>  c:maindlmucaclientudpclientcmc.h(123): note: while trying to match the argument list '(const MessageType, const int)'

使此类功能正常工作的关键是将整型强制转换运算符用于 Value 类型（在本例中为 e 位枚举值）

class MessageType {
public:
    enum class Value : uint8_t {
        undefined = 0, membersystem = 10
    };
    static const MessageType Undefined, MemberSystem;
    // integral operator cast for switch statements (cast to named enum)
    inline operator const Value() const {
        return mValue;
    }
    // strict weak ordering for set ops
    inline bool operator<(const MessageType& rhs) const {
        return mValue < rhs.mValue;
    }
    // serialized version of the enum
    inline std::string getStringVal() const {
        return mStringVal;
    }
    static const std::set<MessageType>& getValues() {
        static std::set<MessageType> gValues;
        if (gValues.empty()) {
            gValues.insert(Undefined);
            gValues.insert(MemberSystem);
        }
        return gValues;
    }
    static MessageType valueOf(const int& rVal) {
        for (const auto& next : getValues()) {
            if (next == rVal) {
                return next;
            }
        }
        throw std::invalid_argument(
            "Illegal Argument: " + rVal);
    }
    static MessageType valueOf(const std::string& rStringVal) {
        for (const auto& next : getValues()) {
            if (next.getStringVal() == rStringVal) {
                return next;
            }
        }
        throw std::invalid_argument(
            "Illegal Argument: " + rStringVal);
    }
private:
    MessageType(const Value& rValue, const std::string& rStringVal)
        : mValue(rValue)
        , mStringVal(rStringVal)
    {}
    Value mValue;
    std::string mStringVal;
};

真正奇怪的是，在这个定义之前，我有一个类似的类，它在没有波浪线的情况下工作正常，如下所示：

class DiscreteStatus {
public:
    enum Value : uint8_t {
        normaloperation = 0, nocomputeddata = 1, functionaltest = 2, failurewarning = 3
    };
    static const DiscreteStatus NormalOperation, NoComputedData, FunctionalTest, FailureWarning;
    // integral operator cast for switch statements (cast to named enum)
    inline operator const Value() const {
        return mValue;
    }
    // strict weak ordering for set ops
    inline bool operator<(const DiscreteStatus& rhs) const {
        return mValue < rhs.mValue;
    }
    // serialized version of the enum
    inline std::string getStringVal() const {
        return mStringVal;
    }
    static const std::set<DiscreteStatus>& getValues() {
        static std::set<DiscreteStatus> gValues;
        if (gValues.empty()) {
            gValues.insert(NormalOperation);
            gValues.insert(NoComputedData);
            gValues.insert(FunctionalTest);
            gValues.insert(FailureWarning);
        }
        return gValues;
    }
    static DiscreteStatus valueOf(const int& rVal) {
        for (const auto& next : getValues()) {
            if (next == rVal) {
                return next;
            }
        }
        throw std::invalid_argument(
            "Illegal Argument: " + rVal);
    }
    static DiscreteStatus valueOf(const std::string& rStringVal) {
        for (const auto& next : getValues()) {
            if (next.getStringVal() == rStringVal) {
                return next;
            }
        }
        throw std::invalid_argument(
            "Illegal Argument: " + rStringVal);
    }
private:
    DiscreteStatus(const Value& rValue, const std::string& rStringVal)
        : mValue(rValue)
        , mStringVal(rStringVal)
    {}
    Value mValue;
    std::string mStringVal;
};

实现文件 （CPP） 按如下方式执行静态初始化：

const DiscreteStatus DiscreteStatus::NormalOperation(DiscreteStatus::Value::normaloperation, "NML");
const DiscreteStatus DiscreteStatus::NoComputedData(DiscreteStatus::Value::nocomputeddata, "NCD");
const DiscreteStatus DiscreteStatus::FunctionalTest(DiscreteStatus::Value::functionaltest, "FT");
const DiscreteStatus DiscreteStatus::FailureWarning(DiscreteStatus::Value::failurewarning, "FW");
const MessageType MessageType::Undefined(MessageType::Value::undefined, "Undefined");
const MessageType MessageType::MemberSystem(MessageType::Value::membersystem, "MemberSystem");

Answer 1

在这两种情况下，目的是调用类型转换运算符，以便执行到相应Value类型的转换。

在第一种情况下，您Value定义如下：

enum class Value : uint8_t

这不像公共继承那样工作，但更类似于私有继承：它是一种在条款中实现的关系。客户端代码不得，在您的情况下不能依赖于Value在内部实现为uint8_t的事实。

但是，在第二种情况下，如下所示：

enum Value : uint8_t

这可以被描绘成类似于公共继承的东西，这意味着客户端代码可以依赖并依赖于Value确实是一个uint8_t的事实。因此，类型转换有效。

现在，您可以通过将第一个定义更改为 enum Value : uint8_t 来快速修复代码，但人们不得不想知道为什么要为带有整数参数的 valueOf 函数提供。它打破了抽象。

---

一般来说，我强烈建议不要采用这种方法。这似乎过于复杂，就像人们试图用语言 B 编写语言 A 时总是如此。

在这种特殊情况下，Java 枚举和 C++11 枚举类之间的任何相似之处都只是表面的。归根结底，从C++的角度来看，Java 枚举是不可复制的类，具有静态常量指针，指向无法取消引用的垃圾回收实例。你不想在C++中效仿这一切，你也不能，也不应该。