Stringa per enum in C++

Question

C'è un modo per associare una stringa da un file di testo con un valore enum?

Il problema è: ho alcuni valori di enumerazione memorizzati come stringa in un file di testo che ho letto al volo incontrando alcune condizioni ... Ora voglio assegnare il valore letto a un enum.

Qual è il modo più efficace per farlo? Non ha bisogno di essere l'approccio più semplice. .

Answer 1

È possibile impostare una mappa che è possibile utilizzare più e più volte:

template <typename T> 
class EnumParser 
{ 
    map <string, T> enumMap; 
public: 
    EnumParser(){}; 

    T ParseSomeEnum(const string &value) 
    { 
     map <string, T>::const_iterator iValue = enumMap.find(value); 
     if (iValue == enumMap.end()) 
      throw runtime_error(""); 
     return iValue->second; 
    } 
}; 

enum SomeEnum 
{ 
    Value1, 
    Value2 
}; 
EnumParser<SomeEnum>::EnumParser() 
{ 
    enumMap["Value1"] = Value1; 
    enumMap["Value2"] = Value2; 
} 

enum OtherEnum 
{ 
    Value3, 
    Value4 
}; 
EnumParser<OtherEnum>::EnumParser() 
{ 
    enumMap["Value3"] = Value3; 
    enumMap["Value4"] = Value4; 
} 

int main() 
{ 
    EnumParser<SomeEnum> parser; 
    cout << parser.ParseSomeEnum("Value2"); 
} 

Answer 2

std::map< string, enumType> enumResolver; 

Answer 3

analizzare la stringa da soli, hanno la stringa con un valore (che è anche un indice a un map<string, enum>

Answer 4

Utilizzando un std::map solleva la questione:? come fa la mappa ottiene inizializzato avrei preferito utilizzare una funzione:

enum E { A, B }; 

E f(const std::string & s) { 
    if (s == "A") { 
     return A; 
    } 
    else if (s == "B") { 
     return B; 
    } 
    else { 
     throw "Your exception here"; 
    } 
} 

Answer 5

Sono d'accordo con molte delle risposte che std::map è la soluzione più semplice.

Se hai bisogno di qualcosa di più veloce, puoi usare una mappa di hash. Forse il tuo compilatore ne offre già uno, come ad esempio hash_map o l'imminente standard unordered_map, oppure puoi ottenerne uno da boost. Quando tutte le stringhe sono conosciute in anticipo, è possibile utilizzare anche perfect hashing.

Answer 6

Vedere Boost.Bimap, fornisce associazioni bidirezionali tra due serie di valori. Puoi anche scegliere il contenitore sottostante.

Answer 7

E 'questo quello che vuoi? L'inizializzazione è semplice e non è necessaria alcuna istanziazione.

utilizzo:

enum SomeEnum 
{ 
    ENUM_ONE, 
    ENUM_TWO, 
    ENUM_THREE, 
    ENUM_NULL 
}; 

DEFINE_PAIRLIST(CEnumMap, SomeEnum) 

INIT_PAIRLIST(CEnumMap)= 
{ 
     {"One", ENUM_ONE}, 
     {"Two", ENUM_TWO}, 
     {"Three", ENUM_THREE}, 
     {"", ENUM_NULL} 
}; 

main{ 
    // Get enum from string 
    SomeEnum i = CEnumMap::findValue("One"); 

    // Get string from enum 
    SomeEnum eee = ENUM_ONE; 
    const char* pstr = CEnumMap::findKey(eee); 
    ... 
} 

libreria:

template <class T> 
struct CStringPair 
{ 
    const char* _name; 
    T _value; 
}; 

template <class T, class Derived> 
struct CStringPairHandle 
{ 
    typedef CStringPair<T> CPair; 
    static const CStringPair<T> * getPairList(){ 
     return Derived::implementation(); 
    } 
    static T findValue(const char* name){ 
     const CStringPair<T> * p = getPairList(); 
     for (; p->_name[0]!=0; p++) 
      if (strcmp(name,p->_name)==0) 
       break; 
     return p->_value; 
    } 

    static const char* findKey(T value){ 
     const CStringPair<T> * p = getPairList(); 
     for (; p->_name[0]!=0; p++) 
      if (strcmp(value,p->_value)==0) 
       break; 
     return p->_name; 
    }; 
}; 

#define DEFINE_PAIRLIST(name, type) struct name:public CStringPairHandle<type, name>{ \ 
    static CPair _pairList[];  \ 
    static CPair* implementation(){  \ 
     return _pairList;   \ 
    }}; 
#define INIT_PAIRLIST(name) name::CPair name::_pairList[] 

Answer 8

risposta accettata non contiene lista completa. Sto aggiungendo EnumParser.h che ho creato dalla risposta accettata, la speranza può aiutare

#include <string> 
#include <map> 

using namespace std; 

template <typename T> class EnumParser 
{ 
    map<string, T> enumMap; 
public: 
    EnumParser(){}; 

    T ParseSomeEnum(const string &value) 
    { 
     typename map <string, T>::const_iterator iValue = enumMap.find(value); 
     if (iValue == enumMap.end()) 
      throw runtime_error(""); 
     return iValue->second; 
    } 
}; 

L'uso è semplice:

enum FieldType 
{ 
    Char, 
    Integer, 
    Long, 
    Fixed, 
    Price, 
    Date, 
    Time 
}; 

EnumParser<FieldType>::EnumParser() 
{ 
    enumMap["Char"] = Char; 
    enumMap["Integer"] = Integer; 
    enumMap["Long"] = Long; 
    enumMap["Fixed"] = Fixed; 
    enumMap["Price"] = Price; 
    enumMap["Date"] = Date; 
    enumMap["Time"] = Time; 
} 

uso:

EnumParser<FieldType> fieldTypeParser; 
FieldType val = fieldTypeParser.ParseSomeEnum(stringValue) 

Answer 9

È possibile calcolare l'hash di la stringa e quindi utilizzare questo:

template <typename H, typename E> 
E map_hash(H const key, std::initializer_list<std::pair<H, E>> const il) 
{ 
    auto const i(
    std::find_if(il.begin(), 
     il.end(), 
     [key](auto& p) 
     { 
     return p.first == key; 
     } 
    ) 
); 

    assert(i != il.end()); 

    return i->second; 
}