Как оптимально перевести перечисления в наименьшем количестве кода?

Вы ищете что-то подобное? Не проверял, но должно работать.

(Применяются стандартные предупреждения о преждевременной оптимизации и необходимости профилирования; поиск std::map может быть не таким уж плохим, гигантская таблица переключения может быть не такой уж хорошей.)

перечисления-импл.ч:

// No include guard.
DEFINE_ENUM_PAIR(EGA_BRIGHT_RED, 12, HTML_RED, 0xff0000)
DEFINE_ENUM_PAIR(EGA_BRIGHT_BLUE, 9, HTML_BLUE, 0x0000ff)
DEFINE_ENUM_PAIR(EGA_BRIGHT_GREEN, 10, HTML_GREEN, 0x00ff00)
DEFINE_ENUM_PAIR(EGA_BLACK, 0, HTML_BLACK, 0x000000)

enums.cpp:

enum EgaColorType {
#define DEFINE_ENUM_PAIR(name1, value1, name2, value2) name1 = value1,
#include "enums-impl.h"
#undef DEFINE_ENUM_PAIR
};

enum HtmlColorType {
#define DEFINE_ENUM_PAIR(name1, value1, name2, value2) name2 = value2,
#include "enums-impl.h"
#undef DEFINE_ENUM_PAIR 
};

HtmlColorType ConvertEgaToHtml(EgaColorType c) {
switch (c) {
#define DEFINE_ENUM_PAIR(name1, value1, name2, value2) case name1: return name2;
#include "enums-impl.h"
#undef DEFINE_ENUM_PAIR
default: assert(false);
}

EgaColorType ConvertHtmlToEga(HtmlColorType c) {
switch (c) {
#define DEFINE_ENUM_PAIR(name1, value1, name2, value2) case name2: return name1;
#include "enums-impl.h"
#undef DEFINE_ENUM_PAIR
default: assert(false);
}

Почему не работает таблица поиска? Почему вы вынуждены использовать этот гигантский оператор switch??

Как сказал Нил, я никогда не сталкивался с этой проблемой сам. Однако я столкнулся с проблемой кодовых наборов (т.е. сопоставление строки с перечислением и обратно).

Моя первая реакция эпидермальная: СУХАЯ.

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

Моей второй реакцией было бы попытаться удалить перечисление. Я не люблю перечисления. Возможно, я оценю их в грядущем C++0x, но в нынешнем виде они доставляют больше хлопот, чем того стоят, на мой взгляд. Я предпочитаю смарт-объекты с категориями и т. д.

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

Шаблоны здесь мало что могут сделать. Я использовал их для проверки диапазона в перечислениях и для преобразования строк (туда и обратно) и итераций, но это все, что они могут сделать. Однако, как вы подозревали, это возможно с помощью некоторого «тонкого» применения Boost.Preprocessor.

Что вы хотите написать:

DEFINE_CORRESPONDING_ENUMS(Server, Client,
  ((Server1, 1, Client1, 6))
  ((Server2, 2, Client2, 3))
  ((Common1, 4, Common1, 4))
  ((Common2, 5, Common2, 5))
  ((Server3, 7, Client3, 1))
);

И мы хотели бы, чтобы он сгенерировал:

struct Server
{
  enum type { Server1 = 1, Server2 = 2, Common1 = 4, Common2 = 5, Server3 = 7 };
};

struct Client
{
  enum type { Client1 = 6, Client2 = 3, Common1 = 4, Common2 = 5, Client3 = 1 };
};

Server::type ServerFromClient(Client::type c)
{
  switch(c)
  {
  case Client1: return Server1;
  //...
  default: abort();
  }
}

Client::type ClientFromServer(Server::type s)
{
  //...
}

Хорошая новость в том, что это возможно. Я мог бы даже это сделать, хотя, вероятно, я позволю вам немного поработать над этим;)

Вот некоторые пояснения:

• Третий элемент макроса — это последовательность. Последовательность имеет неограниченный размер.
• Каждый элемент последовательности является четверкой. Вам нужно заранее знать его размер, поэтому повторение для Common. Если бы вы вместо этого использовали последовательность, вы могли бы иметь дело с переменным количеством элементов (например, чтобы избежать повторения общего...), но это значительно усложнило бы ситуацию.
• Вам нужно посмотреть на BOOST_PP_SEQ_FOREACH, здесь это будет основная операция.
• Не забудьте BOOST_PP_CAT для обработки конкатенации токенов.
• на gcc опция -E дает вывод препроцессора, это может пригодиться...
• не забывайте комментарии и как их использовать в файле, иначе ваши коллеги будут вас ненавидеть

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

enum A
{
    MIN_A = 1,
    A_ATT_1 = 1,
    A_ATT_2 = 2,
    A_ATT_3 = 3,
    LAST_A
};

enum B
{
    MIN_B = 2
    B_ATT_2 = 2,
    B_ATT_1 = 4,
    B_ATT_3 = 5,
    LAST_B
};

B A_to_B[] =
{
    B_ATT_1,
    B_ATT_2,
    B_ATT_3
};

// Somewhere that will always run, as desired:
assert(LAST_A - MIN_A == sizeof(A_to_B) / sizeof(A_to_B[0]);

B from_A(A in)
{
    B ret = A_to_B[in - MIN_A];
    assert(ret != LAST_B);
    return ret;
}

A B_to_A[] =
{
    A_ATT_2,
    LAST_A,
    A_ATT_1,
    A_ATT_3
};

// Somewhere that will always run, as desired:
assert(LAST_B - MIN_B == sizeof(B_to_A) / sizeof(B_to_A[0]);

A from_B(B in)
{
    A ret = B_to_A[in - MIN_B];
    assert(ret != LAST_A);
    return ret;
}

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

Не используйте два перечисления.

Между ними нет большой разницы:

enum FirstSet { A=4, B=6, C=8, D=5 };
enum SecondSet { E=2, F=5, G=5, H=1 };

и это:

enum OneEnum { A, B, C, D };
enum TwoEnum { E, F, G, H };
int FirstSet[] = { 4, 6, 8, 5 };
int SecondSet[] = { 2, 5, 5, 1 };

Количество доступов, которые необходимо изменить, может быть непомерно высоким, но это немного лучше, чем поиск O(n) каждый раз, когда вы хотите преобразовать.