Поисковый объект, похожий на enum, с преобразованием строки и int

Тип enum на С++ довольно простой; он в основном просто создает кучу значений времени компиляции для меток (возможно, с правильной областью определения с помощью enum class).

Это очень привлекательно для группировки связанных констант времени компиляции вместе:

Однако он имеет множество предполагаемых недостатков, в том числе:

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

Идеальное решение принимает понятие знания времени компиляции констант и их ассоциаций со строками и объединяет их вместе в объект, подобный переименованию, который можно искать как с перечислением, так и с именем перечисления enum. Наконец, полученный тип использовал бы синтаксис, максимально приближенный к синтаксису enum.

В этом посте я расскажу о том, что другие пытались сделать для отдельных частей, а затем пройдут два подхода, один из которых выполняет вышеупомянутое, но имеет поведение undefined из-за порядка инициализации статических элементов и другое решение который имеет менее симпатичный синтаксис, но не поведение undefined из-за порядка инициализации.

Предварительная работа

Есть много вопросов о SO о получении количества элементов в перечислении (1 2 3) и множество других вопросов в Интернете, запрашивающих одно и то же (4 5 6) и т.д. И общий консенсус в том, что нет уверенного способа сделать это.

Тройка элемента N'th

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

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

Boost Enum

И поэтому разработчики в Boost попытались решить проблему с помощью Boost.Enum, который использует некоторые довольно сложные макросы, чтобы развернуть код, который по крайней мере даст вам размер.

Итерируемые перечисления

Произошло несколько попыток повторных перечислений; enum-подобные объекты, которые можно перебрать, теоретически допуская вычисления неявного размера или даже явно в случае [7] (7 8 9,...)

Преобразование Enum в String

Попытки реализовать это обычно приводят к использованию свободно плавающих функций и использованию макросов для их надлежащего вызова. (8 9 10)

Это также относится к поисковым перечислениям по строке (13)

Дополнительные ограничения

В этот момент становится довольно ясно, что мы больше не можем использовать перечисление. Тем не менее, мне все равно нужен интерфейс, подобный enum для пользователя.

Подход

Скажем, я считаю, что я супер умный и понимаю, что если у меня есть класс A:

Затем я могу получить доступ к myInt, сказав A::myInt.

Я говорю себе: хорошо знаю все мои значения enum загодя, поэтому перечисление в основном выглядит следующим образом:

Затем я хочу стать более привлекательным; позвольте обратиться к ограничению, в котором нам нужны преобразования std::string и int:

И затем я могу объявить некоторый содержащий класс с static EnumValue s:

MyEnum v1

Отлично! Это решает некоторые из наших ограничений, но как насчет поиска в коллекции? Hm, хорошо, если теперь добавить контейнер static, например unordered_map, тогда все становится еще круче! В некоторых #define вы можете сбросить также опечатки строк:

MyEnum v2

Полная рабочая демонстрация ЗДЕСЬ!

Теперь я получаю дополнительное преимущество поиска контейнера перечислений с помощью name или id:

НО

Все это очень плохо. Мы инициализируем много статических данных. Я имею в виду, что до недавнего времени мы могли заполнить map во время компиляции! (11)

Который может быть опосредован с помощью функции getter, которая инициализирует ваши статические данные и возвращает их (12):

Но если я это сделаю, теперь мне нужно вызвать функцию для инициализации моих статических данных, и я потеряю симпатичный синтаксис, который вы видите выше!

~~# Вопросы # Итак, теперь я, наконец, обошел свои вопросы:~~

ИЗМЕНИТЬ

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

Полная рабочая демонстрация v2 ЗДЕСЬ

Вопросы

Что касается награды:

Я считаю, что ответ на этот вопрос также решит проблемы, связанные с перечислениями, которые я разработал в сообщении (Enum в кавычках, потому что результирующий тип не будет перечислением, но мы хотим enum-like поведение):

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

Ответы

Ответ 1

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

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

<enum name="MyEnum">
    <item name="ALPHA" />
    <item name="BETA" />
    <item name="GAMMA" />
</enum>

Достаточно легко добавить любые необязательные поля, которые вам нужны (вам нужен value? Если enum не обладали ли они правами? Имеют ли указанный тип?).

Затем вы пишете генератор кода на выбранном вами языке, который превращает этот файл в файл заголовка С++ (или заголовок/источник) a la:

enum class MyEnum {
    ALPHA,
    BETA,
    GAMMA,
};

std::string to_string(MyEnum e) {
    switch (e) {
    case MyEnum::ALPHA: return "ALPHA";
    case MyEnum::BETA: return "BETA";
    case MyEnum::GAMMA: return "GAMMA";
    }
}

MyEnum to_enum(const std::string& s) {
    static std::unordered_map<std::string, MyEnum> m{
        {"ALPHA", MyEnum::ALPHA},
        ...
    };

    auto it = m.find(s);
    if (it != m.end()) {
        return it->second;
    }
    else {
        /* up to you */
    }
}

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

Ответ 2

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

Эти два вызова макроса:

#define Animal_Members(LAMBDA) \
    LAMBDA(DOG) \
    LAMBDA(CAT) \
    LAMBDA(COW) \

CREATE_ENUM(Animal,None);

Сгенерируйте это:

struct Animal {
  enum Id {
    None,
    DOG,
    CAT,
    COW
  };
  static Id fromString( const char* s ) {
    if( !s ) return None;
    if( strcmp(s,"DOG")==0 ) return DOG;
    if( strcmp(s,"CAT")==0 ) return CAT;
    if( strcmp(s,"COW")==0 ) return COW;
    return None;
  }
  static const char* toString( Id id ) {
    switch( id ) {
      case DOG: return "DOG";
      case CAT: return "CAT";
      case COW: return "COW";
      default: return nullptr;
    }
  }
  static size_t count() {
    static Id all[] = { None, DOG, CAT, COW };
    return sizeof(all) / sizeof(Id);
  }
};

Вы можете объединить их в один макрос, используя BOOST_PP, и иметь последовательность для членов. Это сделало бы его намного менее удобочитаемым. Вы можете легко изменить его на свои предпочтения возвращаемых значений по умолчанию или полностью удалить значение по умолчанию, добавить конкретное значение элемента и имя строки и т.д.
Там нет свободных функций, а не адский порядок ада и только немного макрокода, который очень похож на конечный результат:

#define ENUM_MEMBER(MEMBER)                         \
    , MEMBER
#define ENUM_FROM_STRING(MEMBER)                    \
    if( strcmp(s,#MEMBER)==0 ) return MEMBER;
#define ENUM_TO_STRING(MEMBER)                      \
    case MEMBER: return #MEMBER;
#define CREATE_ENUM_1(NAME,MACRO,DEFAULT)           \
    struct NAME {                                   \
        enum Id {                                   \
            DEFAULT                                 \
            MACRO(ENUM_MEMBER)                      \
        };                                          \
        static Id fromString( const char* s ) {     \
            if( !s ) return DEFAULT;                \
            MACRO(ENUM_FROM_STRING)                 \
            return DEFAULT;                         \
        }                                           \
        static const char* toString( Id id ) {      \
            switch( id ) {                          \
            MACRO(ENUM_TO_STRING)                   \
            default: return nullptr;                \
            }                                       \
        }                                           \
        static size_t count() {                     \
            static Id all[] = { DEFAULT             \
                MACRO(ENUM_MEMBER) };               \
            return sizeof(all) / sizeof(Id);        \
        }                                           \
    };
#define CREATE_ENUM_2(NAME,DEFAULT) \
    CREATE_ENUM_1(NAME,NAME##_Members,DEFAULT)
#define CREATE_ENUM(NAME,DEFAULT) \
    CREATE_ENUM_2(NAME,DEFAULT)

Надеюсь, что это поможет.