在C++中模拟Java Enum

Question

我一直在将我从Java写过的应用程序移植到C++.我很快意识到的一件事是,Java丰富的Enum(在Java 5中引入)远远优于C++中提供的那些.C++ 0x,以及后来的C++ 11''强类型枚举'(又名枚举类)仍然没有提供Java Enums提供的丰富性,我找不到任何可以在这里模拟这个工具的东西.

我开始尝试模拟一些功能作为类,我希望有一些帮助来实现这一点,可能使用模板(如果合适的话)(似乎应该有更通用的方法来实现它).你会看到,通过一个字符串名来查找特定枚举的能力是相当冗长实现- (这是Java ENUM的的仿真的valueOf(字符串str)方法-它的作品-但我相信,这是远远没有达到最佳我实现Enum实例的方式是使用类中的静态const实例 - 我在Stack Overflow上发现了这个 - 但我不记得究竟在哪里 - 抱歉.

仅供参考,该应用程序是一个NMEA字符串解析器,这里有一些更有趣的Enum类:

这是标题

#ifndef _NMEASentence_h_
#define _NMEASentence_h_

// SYSTEM INCLUDES
#include <stdint.h>
#include <string>

// APPLICATION INCLUDES
// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS

 /**
 *  Name:  NMEASentence
 */
class NMEASentence
{
public:
    static const int MAX_LEN;
    static const char START;
    static const char CKSM_DELIM;
    static const char CR;
    static const char LF;

    NMEASentence(
        const std::string rPrefix,
        const std::string& rParams)
        : mPrefix(rPrefix)
        , mParams(rParams)
    {};

    // make the class abstract
    virtual ~NMEASentence() = 0;

protected:
    std::string mPrefix;
    std::string mParams;
};

#endif // _NMEASentence_h_

这是CPP

// SYSTEM INCLUDES
// APPLICATION INCLUDES
#include "vcdu/NMEASentence.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STATIC VARIABLE INITIALIZATIONS
const int NMEASentence::MAX_LEN = 82;
const char NMEASentence::START = '$';
const char NMEASentence::CKSM_DELIM = '*';
const char CR = '\r';
const char LF = '\n';    

// implementation of the pure virtual dtor allowed
// its a trick to allow class to be abstract
NMEASentence::~NMEASentence()
{};

这是通用NMEASentence类的子类

#ifndef _CDUMessage_h_
#define _CDUMessage_h_

// SYSTEM INCLUDES
//#include <...>

// APPLICATION INCLUDES
#include "vcdu/NMEASentence.h"
#include "vcdu/CDUEnumConstants.h"

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS

/**
 * CDUMessage
 */
class CDUMessage : public NMEASentence
{
public:
    /**
     * 5 classifications of message types, The type specifies the
     * number and type of each parameter
     */
    typedef enum CDUMessageSubType {
        Alive,
        Display,
        XYDisplay,
        Status,
        Keyboard,
        Configuration
    } CDUMessageSubType;

    /**
     * enumeration of the supported message types & their arg count
     */
    static class CDUMessageType {
    public:
        static const CDUMessageType CDUAlive;
        // the following 3 messages are associated with the title line
        static const CDUMessageType CDUDisplayDataStatusBlock;
        static const CDUMessageType CDUDisplayTitle;
        static const CDUMessageType CDUDisplayPageNumber;
        // these messages are associated with the active display area
        static const CDUMessageType CDUDisplayScratchPad;
        static const CDUMessageType CDUDisplayLS1Text;
        static const CDUMessageType CDUDisplayLS2Text;
        static const CDUMessageType CDUDisplayLS3Text;
        static const CDUMessageType CDUDisplayLS4Text;
        static const CDUMessageType CDUDisplayLS5Text;
        static const CDUMessageType CDUDisplayLS6Text;
        static const CDUMessageType CDUDisplayLS1SText;
        static const CDUMessageType CDUDisplayLS2SText;
        static const CDUMessageType CDUDisplayLS3SText;
        static const CDUMessageType CDUDisplayLS4SText;
        static const CDUMessageType CDUDisplayLS5SText;
        static const CDUMessageType CDUDisplayLS6SText;
        static const CDUMessageType CDUDisplayRS1Text;
        static const CDUMessageType CDUDisplayRS2Text;
        static const CDUMessageType CDUDisplayRS3Text;
        static const CDUMessageType CDUDisplayRS4Text;
        static const CDUMessageType CDUDisplayRS5Text;
        static const CDUMessageType CDUDisplayRS6Text;
        static const CDUMessageType CDUDisplayRS1SText;
        static const CDUMessageType CDUDisplayRS2SText;
        static const CDUMessageType CDUDisplayRS3SText;
        static const CDUMessageType CDUDisplayRS4SText;
        static const CDUMessageType CDUDisplayRS5SText;
        static const CDUMessageType CDUDisplayRS6SText;
        // this is a special message to clear the screen buffer
        static const CDUMessageType CDUDisplayCLS;
        static const CDUMessageType CDUDisplayPutString;
        static const CDUMessageType CDUStatus;
        static const CDUMessageType CDUKeyboard;
        static const CDUMessageType CDUSet;
        static const CDUMessageType CDUGet;

        inline std::string getPrefix() const {
            return mPrefix;
        }

        inline CDUMessageSubType getMesageSubType() const {
            return mSubType;
        }

        inline virtual int getTextRowIndex() const {
            return mTextRowIndex;
        }

        inline JustifyStyle getJustifyStyle() const {
            return mJustifyStyle;
        }

        static std::vector<CDUMessageType>& getValues() {
            static std::vector<CDUMessageType> gValues;
            if (gValues.empty()) {
                gValues.push_back(CDUAlive);
                gValues.push_back(CDUDisplayDataStatusBlock);
                gValues.push_back(CDUDisplayTitle);
                gValues.push_back(CDUDisplayPageNumber);
                gValues.push_back(CDUDisplayScratchPad);
                gValues.push_back(CDUDisplayLS1Text);
                gValues.push_back(CDUDisplayLS2Text);
                gValues.push_back(CDUDisplayLS3Text);
                gValues.push_back(CDUDisplayLS4Text);
                gValues.push_back(CDUDisplayLS5Text);
                gValues.push_back(CDUDisplayLS6Text);
                gValues.push_back(CDUDisplayLS1SText);
                gValues.push_back(CDUDisplayLS2SText);
                gValues.push_back(CDUDisplayLS3SText);
                gValues.push_back(CDUDisplayLS4SText);
                gValues.push_back(CDUDisplayLS5SText);
                gValues.push_back(CDUDisplayLS6SText);
                gValues.push_back(CDUDisplayRS1Text);
                gValues.push_back(CDUDisplayRS2Text);
                gValues.push_back(CDUDisplayRS3Text);
                gValues.push_back(CDUDisplayRS4Text);
                gValues.push_back(CDUDisplayRS5Text);
                gValues.push_back(CDUDisplayRS6Text);
                gValues.push_back(CDUDisplayRS1SText);
                gValues.push_back(CDUDisplayRS2SText);
                gValues.push_back(CDUDisplayRS3SText);
                gValues.push_back(CDUDisplayRS4SText);
                gValues.push_back(CDUDisplayRS5SText);
                gValues.push_back(CDUDisplayRS6SText);
                gValues.push_back(CDUDisplayCLS);
                gValues.push_back(CDUDisplayPutString);
                gValues.push_back(CDUStatus);
                gValues.push_back(CDUKeyboard);
                gValues.push_back(CDUSet);
                gValues.push_back(CDUGet);
            }
            return gValues;
        }
    private:
        CDUMessageType(const std::string& rPrefix,
            const CDUMessageSubType& rSubType,
            const JustifyStyle& rJustifyStyle,
            const int& rTextRowIndex)
            : mPrefix (rPrefix)
            , mSubType (rSubType)
            , mJustifyStyle(rJustifyStyle)
            , mTextRowIndex(rTextRowIndex)
        {}

        std::string mPrefix;
        CDUMessageSubType mSubType;
        JustifyStyle mJustifyStyle;
        int mTextRowIndex;
    };

    CDUMessageType getMessageType() const {
        return mMessageType;
    };

    virtual ~CDUMessage(){};
protected:
    /**
     * Alternative Simplified Constructor
     * @param aMessageType
     * @param aParams
     */
    CDUMessage(const CDUMessageType& rMessageType, const std::string& rParams)
        : NMEASentence (rMessageType.getPrefix(), rParams)
        , mMessageType (rMessageType)
    {};

    CDUMessageType mMessageType;
};

#endif // _CDUMessage_h_

和相应的CPP

// SYSTEM INCLUDES
//#include <...>

// APPLICATION INCLUDES
#include "vcdu/CDUMessage.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STATIC VARIABLE INITIALIZATIONS
// this is the heartbeat message (not associated with any line => -1 for last paramter)
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUAlive ("PCDUALIVE", CDUMessage::Alive, JustifyStyle::Left, -1);

// the following 3 messages are associated with the title line
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayDataStatusBlock("PCDUDSB", CDUMessage::Display,  JustifyStyle::Left, 0);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayTitle("PCDUTIT", CDUMessage::Display, JustifyStyle::Center, 0);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayPageNumber("PCDUPGE", CDUMessage::Display, JustifyStyle::Right, 0);

// these messages are associated with the active display area
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayScratchPad("PCDUSPD", CDUMessage::Display,  JustifyStyle::Left, 13);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS1Text("PCDUL1T", CDUMessage::Display,  JustifyStyle::Left, 2);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS2Text("PCDUL2T", CDUMessage::Display,  JustifyStyle::Left, 4);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS3Text("PCDUL3T", CDUMessage::Display,  JustifyStyle::Left, 6);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS4Text("PCDUL4T", CDUMessage::Display,  JustifyStyle::Left, 8);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS5Text("PCDUL5T", CDUMessage::Display,  JustifyStyle::Left, 10);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS6Text("PCDUL6T", CDUMessage::Display,  JustifyStyle::Left, 12);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS1SText("PCDUL1S", CDUMessage::Display,  JustifyStyle::Left, 1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS2SText("PCDUL2S", CDUMessage::Display,  JustifyStyle::Left, 3);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS3SText("PCDUL3S", CDUMessage::Display,  JustifyStyle::Left, 5);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS4SText("PCDUL4S", CDUMessage::Display,  JustifyStyle::Left, 7);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS5SText("PCDUL5S", CDUMessage::Display,  JustifyStyle::Left, 9);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayLS6SText("PCDUL6S", CDUMessage::Display,  JustifyStyle::Left, 11);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS1Text("PCDUR1T", CDUMessage::Display, JustifyStyle::Right, 2);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS2Text("PCDUR2T", CDUMessage::Display, JustifyStyle::Right, 4);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS3Text("PCDUR3T", CDUMessage::Display, JustifyStyle::Right, 6);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS4Text("PCDUR4T", CDUMessage::Display, JustifyStyle::Right, 8);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS5Text("PCDUR5T", CDUMessage::Display, JustifyStyle::Right, 10);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS6Text("PCDUR6T", CDUMessage::Display, JustifyStyle::Right, 12);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS1SText("PCDUR1S", CDUMessage::Display, JustifyStyle::Right, 1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS2SText("PCDUR2S", CDUMessage::Display, JustifyStyle::Right, 3);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS3SText("PCDUR3S", CDUMessage::Display, JustifyStyle::Right, 5);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS4SText("PCDUR4S", CDUMessage::Display, JustifyStyle::Right, 7);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS5SText("PCDUR5S", CDUMessage::Display, JustifyStyle::Right, 9);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayRS6SText("PCDUR6S", CDUMessage::Display, JustifyStyle::Right, 11);

// these messages are not associated with a paricular line# which is why we specify -1 for the last parameter
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayCLS("PCDUCLS", CDUMessage::Display,  JustifyStyle::Left, -1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUDisplayPutString("PCDUPUTS", CDUMessage::XYDisplay,  JustifyStyle::None, -1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUStatus("PCDUSID", CDUMessage::Status,  JustifyStyle::Left, -1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUKeyboard("PCDUKEY", CDUMessage::Keyboard,  JustifyStyle::Left, -1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUSet("PCDUSETV", CDUMessage::Configuration,  JustifyStyle::Left, -1);
const CDUMessage::CDUMessageType CDUMessage::CDUMessageType::CDUGet("PCDUGETV", CDUMessage::Configuration, JustifyStyle::Left, -1);

为了展示如何使用枚举的一般模式,我们还需要在整个应用程序中使用其他一些Enum C++类.它们看起来非常相似,我不禁觉得必须有一种更简单,更简洁的方式来实现它.任何帮助或想法都会非常受欢迎.

class JustifyStyle {
public:
    static const JustifyStyle Left, Center, Right, None;
    inline std::string getName() const {
        return mName;
    }
private:
    JustifyStyle(const std::string& rName) 
        : mName(rName)
    {}
    std::string mName;
};

class FontSize {
public:
    static const FontSize F1, F2, F3, F4, F5, F6;
    inline std::string getName() const {
        return mName;
    }
    static std::vector<FontSize>& getValues() {
        static std::vector<FontSize> gValues;
        if (gValues.empty()) {
            gValues.push_back(F1);
            gValues.push_back(F2);
            gValues.push_back(F3);
            gValues.push_back(F4);
            gValues.push_back(F5);
            gValues.push_back(F6);
        }
        return gValues;
    }
private:
    FontSize(const std::string& rName) 
        : mName(rName)
    {}
    std::string mName;
};

class FontStyle {
public:
    static const FontStyle S, B, I, U, N;
    inline std::string getName() const {
        return mName;
    }
    static std::vector<FontStyle>& getValues() {
        static std::vector<FontStyle> gValues;
        if (gValues.empty()) {
            gValues.push_back(S);
            gValues.push_back(B);
            gValues.push_back(I);
            gValues.push_back(U);
            gValues.push_back(N);
        }
        return gValues;
    }
    inline bool operator<(const FontStyle& rhs) const {
        return mName < rhs.mName;
    }
private:
    FontStyle(const std::string& rName) 
        : mName(rName)
    {}
    std::string mName;
};

class FontColor {
public:
    static const FontColor BLACK, CYAN, RED, YELLOW, GREEN, MAGENTA, AMBER, WHITE;
    inline int getValue() const {
        return mValue;
    }
    inline std::string getValueStr() const {
        return UtlStringUtils::integerToString(mValue);
    }
    static std::vector<FontColor>& getValues() {
        static std::vector<FontColor> gValues;
        if (gValues.empty()) {
            gValues.push_back(BLACK);
            gValues.push_back(CYAN);
            gValues.push_back(RED);
            gValues.push_back(YELLOW);
            gValues.push_back(GREEN);
            gValues.push_back(MAGENTA);
            gValues.push_back(AMBER);
            gValues.push_back(WHITE);
        }
        return gValues;
    }
private:
    // constructor
    FontColor(const int& rValue) 
        : mValue(rValue)
    {}
    int mValue;
};

class CDUFontChar {
public:
    // constructor
    CDUFontChar (
        const char cduChar = '\0',
        const FontSize& rSize = FontSize::F3,
        const std::set<FontStyle>& rStyles = std::set<FontStyle>(),
        const FontColor& rColor = FontColor::WHITE) 
        : mCDUChar (cduChar)
        , mSize (rSize)
        , mFontStyles(rStyles)
        , mColor(rColor)
    {}

    inline char getCDUChar() const {
        return mCDUChar;
    }

    inline FontSize getSize() const {
        return mSize;
    }

    inline std::set<FontStyle> getStyles() const {
        return mFontStyles;
    }

    inline FontColor getColor() const {
        return mColor;
    }
private:
    char mCDUChar;
    FontSize mSize;
    std::set<FontStyle> mFontStyles;
    FontColor mColor;
};

Answer 1

基本上,Java enum是一种语言特性,旨在跨越常量和不良实践的良好实践或单例的反模式之间的桥梁.C++使得enum无聊的整数常量和Java使它们成为完全面向对象的单例,但希望开发人员能够牢记他们的const根本.所以是的,你完全正确 - 移植的方法是使用C++全局常量.严格来说,Java枚举不一定是常量,例如它们可以有非final字段,但我会(并认为"这是")认为这是一种不好的做法,所以类似地,C++枚举中的所有方法都应该是语义上的const.

Answer 2

自从我提出了堆栈溢出的问题以来，我有机会改进我一直用来模拟 C++ 中的 Java 枚举的方法。下面显示的代码（在标头和实现 cpp 文件中）以及显示如何在 switch 语句中使用枚举的代码片段是我最终在整个代码中使用的内容。微妙之处在于整型转换运算符的使用（在本例中是通过使用 Value 自定义运算符，如下所示）。

// integral operator cast for switch statements (cast to named enum)
inline operator const Value() const {
    return mValue;
}

在头文件CDUEnumConstants.h中：

#ifndef _cduEnumConstants_h_
#define _cduEnumConstants_h_

// SYSTEM INCLUDES
#include <set>
#include <map>
#include <vector>
#include <string>
#include <algorithm>
#include <iostream>

// APPLICATION INCLUDES
#include "util/UtlExceptions.h"
#include "util/UtlStringUtils.h"

// DEFINES
// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
class Annunciator {
public:
    enum Value {
        // these are all undefined in the discrete sense
        undefined=-1, power=-2, fail=-3,
        // these are discrete bits
        exec=(1<<6), dspy=(1<<7), msg=(1<<8), ofst=(1<<9)
    };
    static const Annunciator AnnunciatorUNDEFINED;
    static const Annunciator AnnunciatorPOWER;
    static const Annunciator AnnunciatorFAIL;
    static const Annunciator AnnunciatorEXEC;
    static const Annunciator AnnunciatorDSPY;
    static const Annunciator AnnunciatorMSG;
    static const Annunciator AnnunciatorOFST;
    // used to store in a set
    inline bool operator<(const Annunciator& rhs) const {
        return mValue < rhs.mValue;
    }
    // used for comparisons
    inline bool operator==(const Annunciator& rhs) const {
        return mValue == rhs.mValue;
    }
    inline bool supported() const {
        return mValue > 0;
    }
    // integral operator cast for switch statements (cast to named enum)
    inline operator const Value() const {
        return mValue;
    }

    inline std::string getStringVal() const {
        return mStringVal;
    }

    static const std::set<Annunciator>& getValues() {
        static std::set<Annunciator> gValues;
        if (gValues.empty()) {
            gValues.insert(AnnunciatorUNDEFINED);
            gValues.insert(AnnunciatorPOWER);
            gValues.insert(AnnunciatorFAIL);
            gValues.insert(AnnunciatorEXEC);
            gValues.insert(AnnunciatorDSPY);
            gValues.insert(AnnunciatorMSG);
            gValues.insert(AnnunciatorOFST);
        }
        return gValues;
    }
    static Annunciator valueOf(const std::string& rStringVal) {
        for (const auto& next : getValues()) {
            if (next.getStringVal() == rStringVal) {
                return next;
            }
        }
        throw new UtlIllegalArgumentException(
            "Illegal Argument: " + rStringVal);
    }
private:
    Annunciator(const Value& rValue, const std::string& rStringVal)
        : mValue(rValue)
        , mStringVal(rStringVal)
    {}
    Value mValue;
    std::string mStringVal;
};


// FORWARD DECLARATIONS

// Extendable in the future
class CDUVariable {
public:
    enum Value {
        baud, firmware, type, serial
    };
    static const CDUVariable Baud, Firmware, Type, Serial;
    // used to store in a set
    inline bool operator<(const CDUVariable& rhs) const {
        return mValue < rhs.mValue;
    }
    // used for comparisons
    inline bool operator==(const CDUVariable& rhs) const {
        return mValue == rhs.mValue;
    }
    // integral operator cast for switch statements (cast to named enum)
    inline operator const Value() const {
        return mValue;
    }
    inline std::string getStringVal() const {
        return mStringVal;
    }
    static const std::set<CDUVariable>& getValues() {
        static std::set<CDUVariable> gValues;
        if (gValues.empty()) {
            gValues.insert(Baud);
            gValues.insert(Firmware);
            gValues.insert(Type);
            gValues.insert(Serial);
        }
        return gValues;
    }
    static CDUVariable valueOf(const std::string& rStringVal) {
        for (const auto& next : getValues()) {
            if (next.getStringVal() == rStringVal) {
                return next;
            }
        }
        throw new UtlIllegalArgumentException(
            "Illegal Argument: " + rStringVal);
    }
private:
    CDUVariable(const Value& rValue, const std::string& rStringVal)
        : mValue(rValue)
        , mStringVal(rStringVal)
    {}
    Value mValue;
    std::string mStringVal;
};

#endif // _cduEnumConstants_h_

并在实现CDUEnumConstants.cpp文件中初始化枚举的初始值。

const Annunciator Annunciator::AnnunciatorUNDEFINED(Annunciator::undefined, "UNDEFINED");
const Annunciator Annunciator::AnnunciatorPOWER(Annunciator::power, "POWER");
const Annunciator Annunciator::AnnunciatorFAIL(Annunciator::fail, "FAIL");
const Annunciator Annunciator::AnnunciatorEXEC(Annunciator::exec, "EXEC");
const Annunciator Annunciator::AnnunciatorDSPY(Annunciator::dspy, "DSPY");
const Annunciator Annunciator::AnnunciatorMSG(Annunciator::msg, "MSG");
const Annunciator Annunciator::AnnunciatorOFST(Annunciator::ofst, "OFST");

const CDUVariable CDUVariable::Baud(CDUVariable::baud, "0");
const CDUVariable CDUVariable::Firmware(CDUVariable::firmware, "1");
const CDUVariable CDUVariable::Type(CDUVariable::type, "2");
const CDUVariable CDUVariable::Serial(CDUVariable::serial, "3");

现在，要在用户代码的 switch 语句中使用CDUVariable枚举（忽略其他方法详细信息），请使用以下命令。

std::unique_ptr<EngravityMessage>
VCDUManager::getConfigValue(
    const CDU_ID& rCduID,
    const std::unique_ptr<EngravityMessage>& rVarNameMessage)
{
    EngravityConfigMessage* pVariableName =
        static_cast<EngravityConfigMessage*>(rVarNameMessage.get());
    gpLogManager->add(FAC_PROCESS, PRI_NOTICE,
        "CDU_%d: getConfigValue\n", rCduID);
    CDUVariable variable = pVariableName->getCDUVariable();
    std::unique_ptr<EngravityMessage> variableValue;
    switch (variable) {
    case CDUVariable::baud:
        variableValue = std::unique_ptr<EngravityMessage>(
            new EngravityConfigMessage (
                EngravityMessageType::SetV, variable, "38400"));
        break;
    case CDUVariable::firmware:
        variableValue = std::unique_ptr<EngravityMessage>(
            new EngravityConfigMessage (
                EngravityMessageType::SetV, variable, "1.04"));
        break;
    case CDUVariable::type:
        variableValue = std::unique_ptr<EngravityMessage>(
            new EngravityConfigMessage (
                EngravityMessageType::SetV, variable, "737-NG"));
        break;
    case CDUVariable::serial:
        variableValue = std::unique_ptr<EngravityMessage>(
            new EngravityConfigMessage (
                EngravityMessageType::SetV, variable, "0074"));
        break;
    default:
        break;
    }
    return variableValue;
}

我提供了 2 个 Enum 示例有两个原因，首先我想展示如何从字符串中查找 Enum 值 - 该值经过优化以使用排序集，其次，这里的模式似乎暗示了模板编程 - 但我没有机会将其实现为模板 - 实际上我不确定它是否可以。