Cpp enum to char

Best ways to convert an enum to a string

One of the oldest problem C++ developers ever encountered is how to print the value of an enum type.

All right, I may be a little overly dramatic here, but this is an issue many C++ developers encountered, even the most casual ones.

The thing is, there isn’t one true answer to that issue. It depends on many things such as your constraints, your needs, and, as always, the C++ version of your compiler.

This article is a small list of ways to add reflection to enums.

NB: If you know of a way that isn’t listed here and has its own benefits, feel free to share in the comments.

Magic Enum library

Magic Enum is a header-only library that gives static reflection to enums.

You can convert from and to strings and you can iterate over the enum values. It adds the “enum_cast” feature.

Drawbacks

• It’s a third-party library.
• Only works in C++17.
• You need specific versions of your compiler for it to work (Clang >= 5, MSVC >= 15.3 and GCC >= 9).
• You have a few other constraints related to the implementation of the library. Check the Limitations page of the documentation (magic_enum/limitations.md at master · Neargye/magic_enum · GitHub)

Using a dedicated function with an exception

Static version

constexpr is a magnificent tool that allows us to statically define stuff. When used as the return value of a function, it allows us to evaluate the return value of the function at compile time.

In this version, I added an exception in the default , so if it happens so that an item is added, the exception will be raised.

#include enum class Esper < Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek >; constexpr const char* EsperToString(Esper e) throw() < switch (e) < case Esper::Unu: return "Unu"; case Esper::Du: return "Du"; case Esper::Tri: return "Tri"; case Esper::Kvar: return "Kvar"; case Esper::Kvin: return "Kvin"; case Esper::Ses: return "Ses"; case Esper::Sep: return "Sep"; case Esper::Ok: return "Ok"; case Esper::Naux: return "Naux"; case Esper::Dek: return "Dek"; default: throw std::invalid_argument("Unimplemented item"); >> int main()

Dynamic version

The thing is, h aving several returns in a constexpr function is C++14. Prior to C++14, you can remove the constexpr specifier to write a dynamic version of this function

#include enum class Esper < Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek >; const char* EsperToString(Esper e) throw() < switch (e) < case Esper::Unu: return "Unu"; case Esper::Du: return "Du"; case Esper::Tri: return "Tri"; case Esper::Kvar: return "Kvar"; case Esper::Kvin: return "Kvin"; case Esper::Ses: return "Ses"; case Esper::Sep: return "Sep"; case Esper::Ok: return "Ok"; case Esper::Naux: return "Naux"; case Esper::Dek: return "Dek"; default: throw std::invalid_argument("Unimplemented item"); >> int main()

Prior to C++11, you can remove the enum class specifier and use a plain enum instead.

Drawbacks

• Having several returns in a constexpr function is C++14 (for the static version).
• Specific to each enum and very verbose.
• Is exception-unsafe.

Using a dedicated exception-safe function

Static version

Sometimes you prefer a code that doesn’t throw, no matter what. Or maybe you are like me and compile with -Werror . If so, you can write an exception-safe function without the default case.

You just have to watch out for warnings when you need to add an item.

#include enum class Esper < Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek >; constexpr const char* EsperToString(Esper e) noexcept < switch (e) < case Esper::Unu: return "Unu"; case Esper::Du: return "Du"; case Esper::Tri: return "Tri"; case Esper::Kvar: return "Kvar"; case Esper::Kvin: return "Kvin"; case Esper::Ses: return "Ses"; case Esper::Sep: return "Sep"; case Esper::Ok: return "Ok"; case Esper::Naux: return "Naux"; case Esper::Dek: return "Dek"; >> int main()

Dynamic version

Again, a dynamic version without constexpr :

#include enum class Esper < Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek >; const char* EsperToString(Esper e) noexcept < switch (e) < case Esper::Unu: return "Unu"; case Esper::Du: return "Du"; case Esper::Tri: return "Tri"; case Esper::Kvar: return "Kvar"; case Esper::Kvin: return "Kvin"; case Esper::Ses: return "Ses"; case Esper::Sep: return "Sep"; case Esper::Ok: return "Ok"; case Esper::Naux: return "Naux"; case Esper::Dek: return "Dek"; >> int main()

Prior to C++11, you can remove the enum class specifier and use a plain enum instead.

Drawbacks

• Having several returns in a constexpr function is C++14 (for the static version).
• Specific to each enum and very verbose.
• The warnings are prone to be ignored.

Using macros

Macros can do many things that dynamic code can’t do. Here are two implementations using macros.

Static version

#include #define ENUM_MACRO(name, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)\ enum class name < v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 >;\ const char *name##Strings[] = < #v1, #v2, #v3, #v4, #v5, #v6, #v7, #v8, #v9, #v10>;\ template\ constexpr const char *name##ToString(T value) < return name##Strings[static_cast(value)]; > ENUM_MACRO(Esper, Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek); int main()

Dynamic version

Very similar to the static one, but if you need this in a version prior to C++11, you’ll have to get rid of the constexpr specifier. Also, since it’s a pre-C++11 version, you can’t have enum class , you’ll have to go with a plain enum instead.

#include #define ENUM_MACRO(name, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)\ enum name < v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 >;\ const char *name##Strings[] = < #v1, #v2, #v3, #v4, #v5, #v6, #v7, #v8, #v9, #v10 >;\ const char *name##ToString(int value) < return name##Strings[value]; >ENUM_MACRO(Esper, Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek); int main()

Drawbacks

• Uses macros (I could — has and will — write an article about why macros are bad practice in C++, but won’t do it here. For now, just keep in mind that if you don’t know why macros can be bad, then you shouldn’t use them)
• You need to write a different macro each time you need a reflective enum with a different number of items (with a different macro name, which is upsetting).

Using macros and boost

We can work around the “fixed number of enum items” drawback of the previous version by using Boost.

Static version

#include #include #define PROCESS_ONE_ELEMENT(r, unused, idx, elem) \ BOOST_PP_COMMA_IF(idx) BOOST_PP_STRINGIZE(elem) #define ENUM_MACRO(name, . )\ enum class name < __VA_ARGS__ >;\ const char *name##Strings[] = < BOOST_PP_SEQ_FOR_EACH_I(PROCESS_ONE_ELEMENT, %%, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) >;\ template\ constexpr const char *name##ToString(T value) < return name##Strings[static_cast(value)]; > ENUM_MACRO(Esper, Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek); int main()

Here, the PROCESS_ONE_ELEMENT “converts” the item to its stringized version (calling BOOST_PP_STRINGIZE ), and the BOOST_PP_SEQ_FOR_EACH_I iterates over every item of __VA_ARGS__ (which is the whole macro’s parameter pack).

Dynamic version

Again, it’s a very similar version of the static one, but without the constexpr or other C++11 specifiers.

#include #include #define PROCESS_ONE_ELEMENT(r, unused, idx, elem) \ BOOST_PP_COMMA_IF(idx) BOOST_PP_STRINGIZE(elem) #define ENUM_MACRO(name, . )\ enum name < __VA_ARGS__ >;\ const char *name##Strings[] = < BOOST_PP_SEQ_FOR_EACH_I(PROCESS_ONE_ELEMENT, %%, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) >;\ const char *name##ToString(int value) < return name##Strings[value]; >ENUM_MACRO(Esper, Unu, Du, Tri, Kvar, Kvin, Ses, Sep, Ok, Naux, Dek); int main()

Drawbacks

NB: While still being a third-party library, the boost library is often more accepted than other libraries (such as the little-known Magic Enum library), that’s (inter alia) why this version may be preferred to the first one.

Wrapping up

Here is a little summary of the methods described here:

Name	Is static?	Is generic?	3rd party libraries	Uses macros?	Is exception-safe?
Magic Enum	Yes (C++17)	Yes	Yes (Magic Enum)	No	No
Function w/ exception	Yes (C++14)	No	No	No	No
Function w/o exception	Yes (C++14)	No	No	No	Yes
Macro	Yes (C++11)	No	No	Yes	Yes
Macro & Boost	Yes (C++11)	Yes	Yes (Boost)	Yes	Yes

Again, if you know a good way to convert enums to string, please say so in the comments.

Thanks for reading and see you next week!

Author: Chloé Lourseyre

7 thoughts on “Best ways to convert an enum to a string”

If you’re going to use macros, this is a much better technique: https://digitalmars.com/articles/b51.html It’s useful for more than just converting enums to strings and really deserves to be more widely known.

I believe the best way is smart usage of macro and preprocessor.
Let’s imagine I’m going to create an enum of colors. Instead of classic
enum class Colors < Red, Blue, … >; I’ll do
enum class Colors
#define COLOR_DEF(NAME, VALUE) NAME = VALUE,
#include « Colors.hh »
#undef COLOR_DEF
>; where Colors.hh is a file with following content
COLOR_DEF(Red, 0)
COLOR_DEF(Blue, 1)
…
COLOR_DEF(Count, N) In order to convert Colors to text I’ll write a function
const char* foo(Colors color)
#define COLOR_DEF(NAME, VALUE) return #NAME;
#include « Colors.hh »
#undef COLOR_DEF
> This is very convenient once you’ll get used to it – you don’t lookup through the codebase is order to add one new value to the enum. You simply change one file and that’s it.

Leave a Reply Cancel reply

You must be logged in to post a comment.

Источник

Удобное преобразование перечислений (enum) в строковые в С++

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

enum State ; enum Direction ; 

Гораздо удобнее, когда во время отладки в консоль выводится сообщение типа “ State: Fidget ” вместо “ State: 1 ”. Также частенько бывает нужно сериализировать перечисления в JSON, YAML или иной формат, причём в виде строковых значений. Помимо того, что строковые воспринимать легче, чем числа, их применение в формате сериализации повышает устойчивость к изменениям численных значений констант перечислений. В идеале, «Fidget» должен ссылаться на Fidget , даже если объявлена новая константа, а Fidget имеет значение, отличное от 1.

К сожалению, в С++ нет возможности легко конвертировать значения перечислений в строковые и обратно. Поэтому разработчики вынуждены прибегать к разным ухищрениям, которые требуют определённой поддержки: жёстко закодированным преобразованиям или к использованию неприглядного ограничительного синтаксиса, наподобие Х-макросов. Кто-то дополнительно использует средства сборки для автоматического преобразования. Естественно, это только усложняет процесс разработки. Ведь перечисления имеют свой собственный синтаксис и хранятся в собственных входных файлах, что не облегчает работу средств сборки в Makefile или файлах проекта.

Однако средствами С++ можно гораздо проще решить задачу преобразования перечислений в строковые.

Есть возможность избежать всех упомянутых трудностей и генерировать перечисления с полной рефлексией на чистом С++. Объявление выглядит так:

BETTER_ENUM(State, int, Idle, Fidget, Walk, Scan, Attack) BETTER_ENUM(Direction, int, North, South, East, West) 

State state = State::Fidget; state._to_string(); // "Fidget" std::cout 

Это делается с помощью нескольких ухищрений, связанных с препроцессором и шаблоном. О них мы немного поговорим в конце статьи.

Помимо преобразования в строковые и обратно, а также поточного ввода/вывода, мы можем ещё и перебирать сгенерированные перечисления:

for (Direction direction : Direction._values()) character.try_moving_in_direction(direction); 

Можно сгенерировать перечисления с разреженными диапазонами, а затем подсчитать:

BETTER_ENUM(Flags, char, Allocated = 1, InUse = 2, Visited = 4, Unreachable = 8) Flags::_size(); // 4 

Если вы работаете в С++ 11, то можете даже сгенерировать код на основе перечислений, потому что все преобразования и циклы могут выполняться в ходе компиляции с помощью функций constexpr . Можно, к примеру, написать такую функцию constexpr , которая будет вычислять максимальное значение перечисления и делать его доступным во время компиляции. Даже если значения констант выбираются произвольно и не объявляются в порядке возрастания.

Вы можете скачать с Github пример реализации макроса, упакованного в библиотеку под названием Better Enums (Улучшенные перечисления). Она распространяется под лицензией BSD, так что с ней можно делать что угодно. В данной реализации имеется один заголовочный файл, так что использовать её очень просто, достаточно добавить enum.h в папку проекта. Попробуйте, возможно, это поможет вам в решении ваших задач.

Как это работает

Для осуществления преобразований между строковыми и значениями перечислений необходимо сгенерировать соответствующий маппинг. Better Enums делает это с помощью создания двух массивов в ходе компиляции. Например, если у вас есть такое объявление:

BETTER_ENUM(Direction, int, North = 1, South = 2, East = 4, West = 8) 

то макрос переделает его в нечто подобное:

struct Direction < enum _Enum : int ; static const int _values[] = ; static const char * const _names[] = ; int _value; // . Функции, использующие вышеприведённое объявление. >; 

А затем перейдет к преобразованию: найдет индекс значения или строковой в _values или _names и вернет его соответствующее значение или строковую в другой массив.

Массив значений

_values генерируется путём обращения к константам внутреннего перечисления _Enum . Эта часть макроса выглядит так:

Это почти правильное объявление массива. Проблема заключается в дополнительных инициализаторах вроде «= 1». Для работы с ними Better Enums определяет вспомогательный тип, предназначенный для оператора присваивания, но игнорирует само присваиваемое значение:

template struct _eat < T _value; template _eat& operator =(Any value) < return *this; >// Игнорирует аргумент. explicit _eat(T value) : _value(value) < >// Преобразует из T. operator T() const < return _value; >// Преобразует в T. > 

Теперь можно включить инициализатор «= 1» в выражение присваивания, не имеющее значения:

 static const int _values[] = <(_eat)North = 1, (_eat)South = 2, (_eat)East = 4, (_eat)West = 8>; 

Массив строковых

Для создания этого массива Better Enums использует ( # ) — препроцессорный оператор перевода в строковое (stringization). Он конвертирует __VA_ARGS__ в нечто подобное:

 static const char * const _names[] = ; 

Теперь мы почти преобразовали имена констант в строковые. Осталось избавиться от инициализаторов. Однако Better Enums этого не делает. Просто при сравнении строковых в массиве _names он воспринимает символы пробелов и равенства как дополнительные границы строк. Так что при поиске “ North = 1 ” Better Enums найдёт только “ North ”.

Можно ли обойтись без макроса?

Вряд ли. Дело в том, что в С++ оператор (#) — единственный способ преобразования токена исходного кода в строковое. Так что в любой библиотеке, автоматически преобразующей перечисления с рефлексией, приходится использовать как минимум один высокоуровневый макрос.

Прочие соображения

Конечно, полностью рассматривать реализацию макроса было бы гораздо скучнее и сложнее, чем это сделано в данной статье. В основном, сложности возникают из-за поддержки работающих с массивами static функций constexpr , из-за особенностей разных компиляторов. Также определённые затруднения могут быть связаны с разложением как можно большей части макроса на шаблоны ради ускорения компиляции (шаблоны не нужно репарсить в ходе создания, а расширения-макросы — нужно).

Источник