Какой тип Enum в C++ вы используете?
Общеизвестно, что встроенные перечисления в C++ не безопасны для типов. Мне было интересно, какие классы, реализующие типизированные перечисления, используются там... Я сам использую следующий "велосипед", но он несколько многословен и ограничен:
typesafeenum.h:
struct TypesafeEnum
{
// Construction:
public:
TypesafeEnum(): id (next_id++), name("") {}
TypesafeEnum(const std::string& n): id(next_id++), name(n) {}
// Operations:
public:
bool operator == (const TypesafeEnum& right) const;
bool operator != (const TypesafeEnum& right) const;
bool operator < (const TypesafeEnum& right) const;
std::string to_string() const { return name; }
// Implementation:
private:
static int next_id;
int id;
std::string name;
};
typesafeenum.cpp:
int TypesafeEnum::next_id = 1;
bool TypesafeEnum::operator== (const TypesafeEnum& right) const
{ return id == right.id; }
bool TypesafeEnum::operator!= (const TypesafeEnum& right) const
{ return !operator== (right); }
bool TypesafeEnum::operator< (const TypesafeEnum& right) const
{ return id < right.id; }
Использование:
class Dialog
{
...
struct Result: public TypesafeEnum
{
static const Result CANCEL("Cancel");
static const Result OK("Ok");
};
Result doModal();
...
};
const Dialog::Result Dialog::Result::OK;
const Dialog::Result Dialog::Result::CANCEL;
Дополнение: я думаю, что я должен был быть более конкретным в отношении требований. Я постараюсь обобщить их:
Приоритет 1. Установка переменной enum на недопустимое значение должна быть невозможной (ошибка времени компиляции) без исключений.
Приоритет 2: Преобразование значения enum в / из int должно быть возможно с помощью одного явного вызова функции / метода.
Приоритет 3: максимально компактное, элегантное и удобное описание и использование
Приоритет 4: Преобразование значений перечисления в и из строк.
Приоритет 5: (приятно иметь) Возможность перебора значений перечисления.
11 ответов
В настоящее время я играю с предложением Boost.Enum от Boost Vault (имя файла enum_rev4.6.zip). Хотя он никогда не был официально представлен для включения в Boost, его можно использовать как есть. (Документация отсутствует, но восполнена чистым исходным кодом и хорошими тестами.)
Boost.Enum позволяет вам объявить перечисление следующим образом:
BOOST_ENUM_VALUES(Level, const char*,
(Abort)("unrecoverable problem")
(Error)("recoverable problem")
(Alert)("unexpected behavior")
(Info) ("expected behavior")
(Trace)("normal flow of execution")
(Debug)("detailed object state listings")
)
И сделайте так, чтобы это автоматически расширилось до этого:
class Level : public boost::detail::enum_base<Level, string>
{
public:
enum domain
{
Abort,
Error,
Alert,
Info,
Trace,
Debug,
};
BOOST_STATIC_CONSTANT(index_type, size = 6);
Level() {}
Level(domain index) : boost::detail::enum_base<Level, string>(index) {}
typedef boost::optional<Level> optional;
static optional get_by_name(const char* str)
{
if(strcmp(str, "Abort") == 0) return optional(Abort);
if(strcmp(str, "Error") == 0) return optional(Error);
if(strcmp(str, "Alert") == 0) return optional(Alert);
if(strcmp(str, "Info") == 0) return optional(Info);
if(strcmp(str, "Trace") == 0) return optional(Trace);
if(strcmp(str, "Debug") == 0) return optional(Debug);
return optional();
}
private:
friend class boost::detail::enum_base<Level, string>;
static const char* names(domain index)
{
switch(index)
{
case Abort: return "Abort";
case Error: return "Error";
case Alert: return "Alert";
case Info: return "Info";
case Trace: return "Trace";
case Debug: return "Debug";
default: return NULL;
}
}
typedef boost::optional<value_type> optional_value;
static optional_value values(domain index)
{
switch(index)
{
case Abort: return optional_value("unrecoverable problem");
case Error: return optional_value("recoverable problem");
case Alert: return optional_value("unexpected behavior");
case Info: return optional_value("expected behavior");
case Trace: return optional_value("normal flow of execution");
case Debug: return optional_value("detailed object state listings");
default: return optional_value();
}
}
};
Он удовлетворяет всем пяти приоритетам, которые вы перечислите.
Хороший компромиссный метод заключается в следующем:
struct Flintstones {
enum E {
Fred,
Barney,
Wilma
};
};
Flintstones::E fred = Flintstones::Fred;
Flintstones::E barney = Flintstones::Barney;
Это не типобезопасно в том же смысле, что и ваша версия, но использование лучше, чем стандартные перечисления, и вы все равно можете воспользоваться преимуществами целочисленного преобразования, когда вам это нужно.
Я использую C++0x типобезопасные перечисления. Я использую некоторые вспомогательные шаблоны / макросы, которые обеспечивают функциональность строки to/from.
enum class Result { Ok, Cancel};
Я не. Слишком много накладных расходов для небольшой выгоды. Кроме того, возможность приведения перечислений к различным типам данных для сериализации является очень удобным инструментом. Я никогда не видел случая, чтобы перечисление "Безопасный тип" стоило бы дополнительных затрат и сложности, когда C++ уже предлагает достаточно хорошую реализацию.
Я лично использую адаптированную версию идиомы типизированного enum. Он не содержит всех пяти "требований", которые вы указали в своем редактировании, но я все равно категорически не согласен с некоторыми из них. Например, я не вижу, как Prio#4 (преобразование значений в строки) имеет какое-либо отношение к безопасности типов. В любом случае, большая часть представления отдельных значений во временной строке должна быть отделена от определения типа (подумайте о i18n по простой причине). Prio#5 (итерация, которая является необязательной) - это одна из самых приятных вещей, которые я хотел бы видеть естественным образом в перечислениях, поэтому мне было грустно, что она выглядит как "необязательная" в вашем запросе, но, похоже, она лучше решается через отдельная итерационная система, такая как begin/end функции или enum_iterator, который позволяет им беспрепятственно работать с STL и C++11 foreach.
OTOH эта простая идиома прекрасно обеспечивает Prio#3 Prio#1 благодаря тому факту, что он в основном только обертывания enumс дополнительной информацией о типе. Не говоря уже о том, что это очень простое решение, которое по большей части не требует каких-либо внешних заголовков зависимостей, поэтому его довольно легко переносить. Он также имеет преимущество в том, что перечисления ограничены а-ля-C++11:
// This doesn't compile, and if it did it wouldn't work anyway
enum colors { salmon, .... };
enum fishes { salmon, .... };
// This, however, works seamlessly.
struct colors_def { enum type { salmon, .... }; };
struct fishes_def { enum type { salmon, .... }; };
typedef typesafe_enum<colors_def> colors;
typedef typesafe_enum<fishes_def> fishes;
Единственная "дыра", которую обеспечивает решение, состоит в том, что оно не учитывает тот факт, что оно не препятствует enumс разных типов (или enum и int) от непосредственного сравнения, потому что когда вы используете значения напрямую, вы заставляете неявное преобразование в int:
if (colors::salmon == fishes::salmon) { .../* Ooops! */... }
Но до сих пор я обнаружил, что такие проблемы можно решить, просто предложив лучшее сравнение с компилятором - например, явно предоставив оператор, который сравнивает любые два разных enum типы, а затем принудительное завершение:
// I'm using backports of C++11 utilities like static_assert and enable_if
template <typename Enum1, typename Enum2>
typename enable_if< (is_enum<Enum1>::value && is_enum<Enum2>::value) && (false == is_same<Enum1,Enum2>::value) , bool >
::type operator== (Enum1, Enum2) {
static_assert (false, "Comparing enumerations of different types!");
}
Хотя кажется, что пока он не нарушает код и явно решает конкретную проблему, не делая ничего другого, я не уверен, что такоенужно делать (я подозреваю, что это будет мешать enumуже участвует в операциях преобразования, объявленных в других местах; Я бы с удовольствием получил комментарий об этом).
Комбинируя это с вышеупомянутой типобезопасной идиомой, вы получаете что-то относительно близкое к C++11 enum class в удобочитаемости (удобочитаемости и ремонтопригодности) без необходимости делать что-то слишком непонятное. И я должен признать, что это было забавно, я никогда не думал спрашивать компилятор, имел ли я дело с enumс или нет...
Я полагаю, что вы придумываете проблему, а затем подбираете решение. Я не вижу необходимости делать сложные рамки для перечисления ценностей. Если вы посвятили себя тому, чтобы ваши значения были только членами определенного набора, вы можете взломать вариант уникального типа данных набора.
Я думаю, что Java enum будет хорошей моделью для подражания. По сути, форма Java будет выглядеть так:
public enum Result {
OK("OK"), CANCEL("Cancel");
private final String name;
Result(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
Что интересно в подходе Java, так это то, что OK а также CANCEL являются неизменными, единичные случаи Result (с методами, которые вы видите). Вы не можете создавать дальнейшие экземпляры Result, Поскольку они одиночные, вы можете сравнивать по указателю / ссылке - очень удобно.:-)
ETA: В Java вместо того, чтобы делать битовые маски вручную, вместо этого вы используете EnumSet указать битовый набор (он реализует Set интерфейс, и работает как наборы --- но реализованы с использованием битовых масок). Гораздо более читабельным, чем рукописные манипуляции с битовой маской!
Я дал ответ на это здесь, на другую тему. Это другой стиль подхода, который позволяет использовать практически те же функции без необходимости изменения исходного определения перечисления (и, следовательно, разрешать использование в тех случаях, когда перечисление не определено). Это также позволяет проверять диапазон во время выполнения.
Недостатком моего подхода является то, что он программно не обеспечивает связывание между enum и вспомогательным классом, поэтому они должны обновляться параллельно. Это работает для меня, но YMMV.
В настоящее время я пишу свою собственную типизированную библиотеку enum по адресу https://bitbucket.org/chopsii/typesafe-enums
Я не самый опытный разработчик C++, но я пишу это из-за недостатков перечислений в хранилище BOOST.
Не стесняйтесь проверить это и использовать их самостоятельно, но у них есть некоторые (возможно, незначительные) проблемы с юзабилити, и они, вероятно, совсем не кроссплатформенные.
Пожалуйста, внесите свой вклад, если хотите. Это мое первое мероприятие с открытым исходным кодом.
Использование boost::variant!
Перепробовав множество вышеперечисленных идей и обнаружив, что их не хватает, я наткнулся на этот простой подход:
#include <iostream>
#include <boost/variant.hpp>
struct A_t {};
static const A_t A = A_t();
template <typename T>
bool isA(const T & x) { if(boost::get<A_t>(&x)) return true; return false; }
struct B_t {};
static const B_t B = B_t();
template <typename T>
bool isB(const T & x) { if(boost::get<B_t>(&x)) return true; return false; }
struct C_t {};
static const C_t C = C_t();
template <typename T>
bool isC(const T & x) { if(boost::get<C_t>(&x)) return true; return false; }
typedef boost::variant<A_t, B_t> AB;
typedef boost::variant<B_t, C_t> BC;
void ab(const AB & e)
{
if(isA(e))
std::cerr << "A!" << std::endl;
if(isB(e))
std::cerr << "B!" << std::endl;
// ERROR:
// if(isC(e))
// std::cerr << "C!" << std::endl;
// ERROR:
// if(e == 0)
// std::cerr << "B!" << std::endl;
}
void bc(const BC & e)
{
// ERROR:
// if(isA(e))
// std::cerr << "A!" << std::endl;
if(isB(e))
std::cerr << "B!" << std::endl;
if(isC(e))
std::cerr << "C!" << std::endl;
}
int main() {
AB a;
a = A;
AB b;
b = B;
ab(a);
ab(b);
ab(A);
ab(B);
// ab(C); // ERROR
// bc(A); // ERROR
bc(B);
bc(C);
}
Вы можете, вероятно, придумать макрос для генерации шаблона. (Дайте мне знать, если вы делаете.)
В отличие от других подходов, этот на самом деле типобезопасен и работает со старым C++. Вы даже можете сделать классные типы, такие как boost::variant<int, A_t, B_t, boost::none>например, для представления значения, которое может быть A, B, целым числом или ничем, что почти соответствует уровню безопасности типа Haskell98.
Недостатки, чтобы быть в курсе:
- по крайней мере, со старым бустом - у меня система с бустом 1,33 - в вашем варианте вы ограничены 20 предметами; есть обходной путь однако
- влияет на время компиляции
- безумные сообщения об ошибках - но это C++ для вас
Обновить
Здесь для вашего удобства есть ваша библиотека типов. Вставьте этот заголовок:
#ifndef _TYPESAFE_ENUMS_H
#define _TYPESAFE_ENUMS_H
#include <string>
#include <boost/variant.hpp>
#define ITEM(NAME, VAL) \
struct NAME##_t { \
std::string toStr() const { return std::string( #NAME ); } \
int toInt() const { return VAL; } \
}; \
static const NAME##_t NAME = NAME##_t(); \
template <typename T> \
bool is##NAME(const T & x) { if(boost::get<NAME##_t>(&x)) return true; return false; } \
class toStr_visitor: public boost::static_visitor<std::string> {
public:
template<typename T>
std::string operator()(const T & a) const {
return a.toStr();
}
};
template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
std::string toStr(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
return boost::apply_visitor(toStr_visitor(), a);
}
class toInt_visitor: public boost::static_visitor<int> {
public:
template<typename T>
int operator()(const T & a) const {
return a.toInt();
}
};
template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
int toInt(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
return boost::apply_visitor(toInt_visitor(), a);
}
#define ENUM(...) \
typedef boost::variant<__VA_ARGS__>
#endif
И используйте это как:
ITEM(A, 0);
ITEM(B, 1);
ITEM(C, 2);
ENUM(A_t, B_t) AB;
ENUM(B_t, C_t) BC;
Обратите внимание, что вы должны сказать A_t вместо A в ENUM макрос, который разрушает часть магии. Ну что ж. Кроме того, обратите внимание, что теперь есть toStr функция и toInt Функция для удовлетворения требований ОП простого преобразования в строки и целые числа. Требование, которое я не могу понять, - это способ перебора элементов. Дайте мне знать, если вы знаете, как написать такую вещь.
Не уверен, что этот пост слишком поздний, но на GameDev.net есть статья, которая удовлетворяет всем, кроме 5-го пункта (возможность перебирать счетчики): http://www.gamedev.net/reference/snippets/features/cppstringizing/
Метод, описанный в статье, обеспечивает поддержку преобразования строк для существующих перечислений без изменения их кода. Если вам нужна поддержка только новых перечислений, я бы пошел с Boost.Enum (упоминалось выше).