C ++: вывести значение enums в виде текста

Если у меня есть перечисление, подобное этому

enum Errors {ErrorA=0, ErrorB, ErrorC}; 

Затем я хочу распечатать на консоль

 Errors anError = ErrorA; cout<<anError;/// 0 will be printed 

но я хочу текст «ErrorA», могу ли я сделать это, не используя if / switch?
И каково ваше решение для этого?

Использование карты:

 #include  #include  #include  enum Errors {ErrorA=0, ErrorB, ErrorC}; std::ostream& operator<<(std::ostream& out, const Errors value){ static std::map strings; if (strings.size() == 0){ #define INSERT_ELEMENT(p) strings[p] = #p INSERT_ELEMENT(ErrorA); INSERT_ELEMENT(ErrorB); INSERT_ELEMENT(ErrorC); #undef INSERT_ELEMENT } return out << strings[value]; } int main(int argc, char** argv){ std::cout << ErrorA << std::endl << ErrorB << std::endl << ErrorC << std::endl; return 0; } 

Использование массива структур с линейным поиском:

 #include  #include  enum Errors {ErrorA=0, ErrorB, ErrorC}; std::ostream& operator<<(std::ostream& out, const Errors value){ #define MAPENTRY(p) {p, #p} const struct MapEntry{ Errors value; const char* str; } entries[] = { MAPENTRY(ErrorA), MAPENTRY(ErrorB), MAPENTRY(ErrorC), {ErrorA, 0}//doesn't matter what is used instead of ErrorA here... }; #undef MAPENTRY const char* s = 0; for (const MapEntry* i = entries; i->str; i++){ if (i->value == value){ s = i->str; break; } } return out << s; } int main(int argc, char** argv){ std::cout << ErrorA << std::endl << ErrorB << std::endl << ErrorC << std::endl; return 0; } 

Использование переключателя / корпуса:

 #include  #include  enum Errors {ErrorA=0, ErrorB, ErrorC}; std::ostream& operator<<(std::ostream& out, const Errors value){ const char* s = 0; #define PROCESS_VAL(p) case(p): s = #p; break; switch(value){ PROCESS_VAL(ErrorA); PROCESS_VAL(ErrorB); PROCESS_VAL(ErrorC); } #undef PROCESS_VAL return out << s; } int main(int argc, char** argv){ std::cout << ErrorA << std::endl << ErrorB << std::endl << ErrorC << std::endl; return 0; } 

Используйте массив или вектор строк с соответствующими значениями:

 char *ErrorTypes[] = { "errorA", "errorB", "errorC" }; cout << ErrorTypes[anError]; 

EDIT: вышеприведенное решение применимо, когда перечисление смежно, т.е. начинается с 0 и нет назначенных значений. Он будет отлично работать с перечислением в вопросе.

Для дальнейшего доказательства этого случая, когда перечисление не начинается с 0, используйте:

 cout << ErrorTypes[anError - ErrorA]; 

Вот пример, основанный на Boost.Preprocessor:

 #include  #include  #include  #include  #include  #include  #include  #include  #define DEFINE_ENUM(name, values) \ enum name { \ BOOST_PP_SEQ_FOR_EACH(DEFINE_ENUM_VALUE, , values) \ }; \ inline const char* format_##name(name val) { \ switch (val) { \ BOOST_PP_SEQ_FOR_EACH(DEFINE_ENUM_FORMAT, , values) \ default: \ return 0; \ } \ } #define DEFINE_ENUM_VALUE(r, data, elem) \ BOOST_PP_SEQ_HEAD(elem) \ BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_SEQ_SIZE(elem), 2), \ = BOOST_PP_SEQ_TAIL(elem), ) \ BOOST_PP_COMMA() #define DEFINE_ENUM_FORMAT(r, data, elem) \ case BOOST_PP_SEQ_HEAD(elem): \ return BOOST_PP_STRINGIZE(BOOST_PP_SEQ_HEAD(elem)); DEFINE_ENUM(Errors, ((ErrorA)(0)) ((ErrorB)) ((ErrorC))) int main() { std::cout << format_Errors(ErrorB) << std::endl; } 

Там была дискуссия, которая могла бы помочь: Есть ли простой способ преобразования C ++ enum в строку?

UPDATE: здесь # sa скрипт для Lua, который создает оператор << для каждого имени enum, с которым он сталкивается. Это может потребовать некоторой работы, чтобы заставить ее работать для менее простых случаев [1]:

 function make_enum_printers(s) for n,body in string.gmatch(s,'enum%s+([%w_]+)%s*(%b{})') do print('ostream& operator<<(ostream &o,'..n..' n) { switch(n){') for k in string.gmatch(body,"([%w_]+)[^,]*") do print(' case '..k..': return o<<"'..k..'";') end print(' default: return o<<"(invalid value)"; }}') end end local f=io.open(arg[1],"r") local s=f:read('*a') make_enum_printers(s) 

Учитывая этот вклад:

 enum Errors {ErrorA=0, ErrorB, ErrorC}; enum Sec { X=1,Y=X,foo_bar=X+1,Z }; 

Он производит:

 ostream& operator<<(ostream &o,Errors n) { switch(n){ case ErrorA: return o<<"ErrorA"; case ErrorB: return o<<"ErrorB"; case ErrorC: return o<<"ErrorC"; default: return o<<"(invalid value)"; }} ostream& operator<<(ostream &o,Sec n) { switch(n){ case X: return o<<"X"; case Y: return o<<"Y"; case foo_bar: return o<<"foo_bar"; case Z: return o<<"Z"; default: return o<<"(invalid value)"; }} 

Так что это, наверное, начало для вас.

[1] enums в разных областях или пространствах без пространства имен, enums с выражениями инициализатора, которые содержат комму и т. Д.

Вы можете использовать более простой препроцессорный трюк, если вы хотите enum записи enum во внешнем файле.

 /* file: errors.def */ /* syntax: ERROR_DEF(name, value) */ ERROR_DEF(ErrorA, 0x1) ERROR_DEF(ErrorB, 0x2) ERROR_DEF(ErrorC, 0x4) 

Затем в исходном файле вы обрабатываете файл как файл include, но вы определяете, что вы хотите сделать ERROR_DEF .

 enum Errors { #define ERROR_DEF(x,y) x = y, #include "errors.def" #undef ERROR_DEF }; static inline std::ostream & operator << (std::ostream &o, Errors e) { switch (e) { #define ERROR_DEF(x,y) case y: return o << #x"[" << y << "]"; #include "errors.def" #undef ERROR_DEF default: return o << "unknown[" << e << "]"; } } 

Если вы используете какой-либо инструмент просмотра исходного кода (например, cscope), вам придется сообщить ему об этом внешнем файле.

Я использую строковый массив всякий раз, когда я определяю перечисление:

Profile.h

 #pragma once struct Profile { enum Value { Profile1, Profile2, }; struct StringValueImplementation { const wchar_t* operator[](const Profile::Value profile) { switch (profile) { case Profile::Profile1: return L"Profile1"; case Profile::Profile2: return L"Profile2"; default: ASSERT(false); return NULL; } } }; static StringValueImplementation StringValue; }; 

Profile.cpp

 #include "Profile.h" Profile::StringValueImplementation Profile::StringValue; 

Это хороший способ,

 enum Rank { ACE = 1, DEUCE, TREY, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING }; 

Распечатайте его массивом массивов символов

 const char* rank_txt[] = {"Ace", "Deuce", "Trey", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Four", "King" } ; 

Как это

 std::cout << rank_txt[m_rank - 1] 

Вы можете использовать контейнер stl map.

 typedef map ErrorMap; ErrorMap m; m.insert(ErrorMap::value_type(ErrorA, "ErrorA")); m.insert(ErrorMap::value_type(ErrorB, "ErrorB")); m.insert(ErrorMap::value_type(ErrorC, "ErrorC")); Errors error = ErrorA; cout << m[error] << endl; 
 #include  using std::cout; using std::endl; enum TEnum { EOne, ETwo, EThree, ELast }; #define VAR_NAME_HELPER(name) #name #define VAR_NAME(x) VAR_NAME_HELPER(x) #define CHECK_STATE_STR(x) case(x):return VAR_NAME(x); const char *State2Str(const TEnum state) { switch(state) { CHECK_STATE_STR(EOne); CHECK_STATE_STR(ETwo); CHECK_STATE_STR(EThree); CHECK_STATE_STR(ELast); default: return "Invalid"; } } int main() { int myInt=12345; cout << VAR_NAME(EOne) " " << VAR_NAME(myInt) << endl; for(int i = -1; i < 5; i) cout << i << " " << State2Str((TEnum)i) << endl; return 0; } 

Для этой проблемы я выполняю вспомогательную функцию следующим образом:

 const char* name(Id id) { struct Entry { Id id; const char* name; }; static const Entry entries[] = { { ErrorA, "ErrorA" }, { ErrorB, "ErrorB" }, { 0, 0 } } for (int it = 0; it < gui::SiCount; ++it) { if (entries[it].id == id) { return entries[it].name; } } return 0; } 

Линейный поиск обычно более эффективен, чем std::map для небольших коллекций, подобных этому.

Это решение не требует использования каких-либо структур данных или создания другого файла.

В основном вы определяете все свои значения enums в #define, а затем используете их в операторе <<. Очень похоже на ответ @ jxh.

Идеальная ссылка для окончательной итерации: http://ideone.com/hQTKQp

Полный код:

 #include  #define ERROR_VALUES ERROR_VALUE(NO_ERROR)\ ERROR_VALUE(FILE_NOT_FOUND)\ ERROR_VALUE(LABEL_UNINITIALISED) enum class Error { #define ERROR_VALUE(NAME) NAME, ERROR_VALUES #undef ERROR_VALUE }; inline std::ostream& operator<<(std::ostream& os, Error err) { int errVal = static_cast(err); switch (err) { #define ERROR_VALUE(NAME) case Error::NAME: return os << "[" << errVal << "]" #NAME; ERROR_VALUES #undef ERROR_VALUE default: // If the error value isn't found (shouldn't happen) return os << errVal; } } int main() { std::cout << "Error: " << Error::NO_ERROR << std::endl; std::cout << "Error: " << Error::FILE_NOT_FOUND << std::endl; std::cout << "Error: " << Error::LABEL_UNINITIALISED << std::endl; return 0; } 

Вывод:

 Error: [0]NO_ERROR Error: [1]FILE_NOT_FOUND Error: [2]LABEL_UNINITIALISED 

Хорошая вещь в том, чтобы делать это таким образом, так это то, что вы можете также указать свои собственные сообщения для каждой ошибки, если считаете, что вам это нужно:

 #include  #define ERROR_VALUES ERROR_VALUE(NO_ERROR, "Everything is fine")\ ERROR_VALUE(FILE_NOT_FOUND, "File is not found")\ ERROR_VALUE(LABEL_UNINITIALISED, "A component tried to the label before it was initialised") enum class Error { #define ERROR_VALUE(NAME,DESCR) NAME, ERROR_VALUES #undef ERROR_VALUE }; inline std::ostream& operator<<(std::ostream& os, Error err) { int errVal = static_cast(err); switch (err) { #define ERROR_VALUE(NAME,DESCR) case Error::NAME: return os << "[" << errVal << "]" #NAME <<"; " << DESCR; ERROR_VALUES #undef ERROR_VALUE default: return os << errVal; } } int main() { std::cout << "Error: " << Error::NO_ERROR << std::endl; std::cout << "Error: " << Error::FILE_NOT_FOUND << std::endl; std::cout << "Error: " << Error::LABEL_UNINITIALISED << std::endl; return 0; } 

Вывод:

 Error: [0]NO_ERROR; Everything is fine Error: [1]FILE_NOT_FOUND; File is not found Error: [2]LABEL_UNINITIALISED; A component tried to the label before it was initialised 

Если вам нравится делать ваши коды ошибок / описания очень описательными, вы можете не захотеть их в производственных assemblyх. Отключение их, поэтому просто напечатать значение легко:

 inline std::ostream& operator<<(std::ostream& os, Error err) { int errVal = static_cast(err); switch (err) { #ifndef PRODUCTION_BUILD // Don't print out names in production builds #define ERROR_VALUE(NAME,DESCR) case Error::NAME: return os << "[" << errVal << "]" #NAME <<"; " << DESCR; ERROR_VALUES #undef ERROR_VALUE #endif default: return os << errVal; } } 

Вывод:

 Error: 0 Error: 1 Error: 2 

Если это так, то поиск номера ошибки 525 будет PITA. Мы можем вручную указать числа в начальном перечислении следующим образом:

 #define ERROR_VALUES ERROR_VALUE(NO_ERROR, 0, "Everything is fine")\ ERROR_VALUE(FILE_NOT_FOUND, 1, "File is not found")\ ERROR_VALUE(LABEL_UNINITIALISED, 2, "A component tried to the label before it was initialised")\ ERROR_VALUE(UKNOWN_ERROR, -1, "Uh oh") enum class Error { #define ERROR_VALUE(NAME,VALUE,DESCR) NAME=VALUE, ERROR_VALUES #undef ERROR_VALUE }; inline std::ostream& operator<<(std::ostream& os, Error err) { int errVal = static_cast(err); switch (err) { #ifndef PRODUCTION_BUILD // Don't print out names in production builds #define ERROR_VALUE(NAME,VALUE,DESCR) case Error::NAME: return os << "[" #VALUE "]" #NAME <<"; " << DESCR; ERROR_VALUES #undef ERROR_VALUE #endif default: return os <(err); break; } } } 

Вывод:

 Error: [0]NO_ERROR; Everything is fine Error: [1]FILE_NOT_FOUND; File is not found Error: [2]LABEL_UNINITIALISED; A component tried to the label before it was initialised Error: [-1]UKNOWN_ERROR; Uh oh 

Как насчет этого?

  enum class ErrorCodes : int{ InvalidInput = 0 }; std::cout << ((int)error == 0 ? "InvalidInput" : "") << std::endl; 

и т. д. Я знаю, что это очень надуманный пример, но я думаю, что он имеет приложение, где это применимо и необходимо, и, конечно, короче, чем писать сценарий для него.

Используйте препроцессор:

 #define VISIT_ERROR(FIRST, MIDDLE, LAST) \ FIRST(ErrorA) MIDDLE(ErrorB) /* MIDDLE(ErrorB2) */ LAST(ErrorC) enum Errors { #define ENUMFIRST_ERROR(E) E=0, #define ENUMMIDDLE_ERROR(E) E, #define ENUMLAST_ERROR(E) E VISIT_ERROR(ENUMFIRST_ERROR, ENUMMIDDLE_ERROR, ENUMLAST_ERROR) // you might undefine the 3 macros defined above }; std::string toString(Error e) { switch(e) { #define CASERETURN_ERROR(E) case E: return #E; VISIT_ERROR(CASERETURN_ERROR, CASERETURN_ERROR, CASERETURN_ERROR) // you might undefine the above macro. // note that this will produce compile-time error for synonyms in enum; // handle those, if you have any, in a distinct macro default: throw my_favourite_exception(); } } 

Преимущество такого подхода состоит в том, что: – он все еще прост для понимания, но – он допускает различные посещения (а не только строки)

Если вы хотите отказаться от первого, создайте макрос FOREACH (), а затем #define ERROR_VALUES() (ErrorA, ErrorB, ErrorC) и напишите своих посетителей в терминах FOREACH (). Затем попробуйте передать обзор кода :).

Пожалуйста, взгляните на это сообщение:

enum to string в современном C ++ 11 / C ++ 14 / C ++ 17 и будущем C ++ 20

DRZ

  • Кто-нибудь знает хороший способ обхода нехватки enum generic constraint?
  • Как получить описание C # Enum из значения?
  • Как перечислить перечисление?
  • Как реализовать перечисление с дженериками?
  • Метод расширения для enums, а не экземпляр enums
  • Требуется ли последняя запятая в C enum?
  • Как преобразовать строку в enum в C #?
  • Как я могу перебирать перечисление?
  • Как сделать gcc предупреждением о передаче неправильного enums функции
  • Перечисление в спящем режиме, сохраняющееся как перечисление
  • Использование значений Enum как строковых литералов
  • Давайте будем гением компьютера.