Cadena de enumeración en C++

Question

¿Hay alguna manera de asociar una cadena de un archivo de texto con un valor enum?

El problema es: Tengo algunos valores enum almacenados como cadena en un archivo de texto que leo sobre la marcha al cumplir alguna condición ... Ahora quiero asignar el valor de lectura a una enumeración.

¿Cuál es la forma más efectiva de hacerlo? No necesita ser el enfoque más simple. .

Answer 1

Puede configurar un mapa que puede utilizar una y otra vez:

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

analizar la cadena de sí mismo, coincide con la cadena de valor (que también es un índice a una map<string, enum>

Answer 4

el uso de un std::map plantea la pregunta: ¿cómo obtener el mapa inicializado prefiero usar una función:

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

Estoy de acuerdo con muchas de las respuestas que std::map es la solución más fácil.

Si necesita algo más rápido, puede usar un mapa hash. Quizás su compilador ya ofrezca uno, como hash_map o el próximo estándar unordered_map, o puede obtener uno de boost. Cuando se conocen todas las cadenas antes de tiempo, también se puede usar perfect hashing.

Answer 6

Mire Boost.Bimap, proporciona asociaciones bidireccionales entre dos conjuntos de valores. También puede elegir el contenedor subyacente.

Answer 7

¿Esto es lo que quieres? La inicialización es recta, y no se necesita instanciación.

uso:

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); 
    ... 
} 

biblioteca:

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

respuesta aceptada no contiene la lista completa. Estoy agregando EnumParser.h la que he creado a partir de la respuesta aceptada, espero que pueda ayudar a

#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; 
    } 
}; 

uso es simple:

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

Se puede calcular el hash de la cadena y luego usar esto:

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; 
}