在C++中模拟Java枚举

Emulating a Java Enum in C++

本文关键字：Java 枚举 模拟 C++      更新时间：2023-10-16

我一直在将我不久前编写的一个应用程序从Java移植到C++。我很快意识到，Java的丰富Enum（在Java5中引入）远远优于C++中提供的Enum。C++0x和后来的C++11的"强类型枚举"（也称为枚举类）仍然没有提供Java枚举所提供的丰富性，我在这里找不到任何可以模仿这种功能的东西。

我开始尝试将一些特性模拟为独立类，我希望能得到一些帮助来实现这一点，如果合适的话，也许可以使用模板（似乎应该有一种更通用的方法来实现这）。您将看到，通过字符串名称查找特定Enum的功能是非常详细地实现的-（这是Java Enum的valueOf（string-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的一般使用模式，我们还有一些其他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 = '',
        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;
};

基本上，Java enum是一种语言特性，旨在跨越常量的良好实践与单例的不良实践或反模式之间的桥梁。C++把enum变成了无聊的整数常量，Java把它们变成了完全面向对象的singleton，但希望开发人员记住它们的const根。所以，是的，你是完全正确的-端口转换的方法是使用C++全局常量。严格来说，Java枚举不一定是常量，例如，它们可以有非最终字段，但我认为（并认为"这就是"）这是一种糟糕的做法，因此类似地，C++枚举中的所有方法在语义上都应该是const。

自从我提出堆栈溢出的问题以来，我有机会改进了在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: getConfigValuen", 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;
}

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

相关文章：