Перечислите по перечислению в C++
Триггеры, кажется, работают хорошо на контрольный вход.
7 ответов
Чтобы добавить к ответу @StackedCrooked , вы можете перегрузить оператор ++ , оператор - и оператор * и имеют функциональность, подобную итератору.
enum Color {
Color_Begin,
Color_Red = Color_Begin,
Color_Orange,
Color_Yellow,
Color_Green,
Color_Blue,
Color_Indigo,
Color_Violet,
Color_End
};
namespace std {
template<>
struct iterator_traits<Color> {
typedef Color value_type;
typedef int difference_type;
typedef Color *pointer;
typedef Color &reference;
typedef std::bidirectional_iterator_tag
iterator_category;
};
}
Color &operator++(Color &c) {
assert(c != Color_End);
c = static_cast<Color>(c + 1);
return c;
}
Color operator++(Color &c, int) {
assert(c != Color_End);
++c;
return static_cast<Color>(c - 1);
}
Color &operator--(Color &c) {
assert(c != Color_Begin);
return c = static_cast<Color>(c - 1);
}
Color operator--(Color &c, int) {
assert(c != Color_Begin);
--c;
return static_cast<Color>(c + 1);
}
Color operator*(Color c) {
assert(c != Color_End);
return c;
}
Давайте протестируем с некоторым шаблоном
void print(Color c) {
std::cout << c << std::endl;
}
int main() {
std::for_each(Color_Begin, Color_End, &print);
}
Теперь Color - это постоянный двунаправленный итератор. Вот многоразовый класс, который я закодировал, делая это вручную выше. Я заметил, что это может работать для многих других перечислений, поэтому повторение одного и того же кода снова и снова довольно утомительно
// Code for testing enum_iterator
// --------------------------------
namespace color_test {
enum Color {
Color_Begin,
Color_Red = Color_Begin,
Color_Orange,
Color_Yellow,
Color_Green,
Color_Blue,
Color_Indigo,
Color_Violet,
Color_End
};
Color begin(enum_identity<Color>) {
return Color_Begin;
}
Color end(enum_identity<Color>) {
return Color_End;
}
}
void print(color_test::Color c) {
std::cout << c << std::endl;
}
int main() {
enum_iterator<color_test::Color> b = color_test::Color_Begin, e;
while(b != e)
print(*b++);
}
Реализация следует.
template<typename T>
struct enum_identity {
typedef T type;
};
namespace details {
void begin();
void end();
}
template<typename Enum>
struct enum_iterator
: std::iterator<std::bidirectional_iterator_tag,
Enum> {
enum_iterator():c(end()) { }
enum_iterator(Enum c):c(c) {
assert(c >= begin() && c <= end());
}
enum_iterator &operator=(Enum c) {
assert(c >= begin() && c <= end());
this->c = c;
return *this;
}
static Enum begin() {
using details::begin; // re-enable ADL
return begin(enum_identity<Enum>());
}
static Enum end() {
using details::end; // re-enable ADL
return end(enum_identity<Enum>());
}
enum_iterator &operator++() {
assert(c != end() && "incrementing past end?");
c = static_cast<Enum>(c + 1);
return *this;
}
enum_iterator operator++(int) {
assert(c != end() && "incrementing past end?");
enum_iterator cpy(*this);
++*this;
return cpy;
}
enum_iterator &operator--() {
assert(c != begin() && "decrementing beyond begin?");
c = static_cast<Enum>(c - 1);
return *this;
}
enum_iterator operator--(int) {
assert(c != begin() && "decrementing beyond begin?");
enum_iterator cpy(*this);
--*this;
return cpy;
}
Enum operator*() {
assert(c != end() && "cannot dereference end iterator");
return c;
}
Enum get_enum() const {
return c;
}
private:
Enum c;
};
template<typename Enum>
bool operator==(enum_iterator<Enum> e1, enum_iterator<Enum> e2) {
return e1.get_enum() == e2.get_enum();
}
template<typename Enum>
bool operator!=(enum_iterator<Enum> e1, enum_iterator<Enum> e2) {
return !(e1 == e2);
}
В настоящее время C ++ не поддерживает итерацию перечислителя. Несмотря на это, в этом иногда возникает необходимость. Обычный обходной путь - добавить значения, обозначающие начало и конец. Например:
enum Color
{
Color_Begin,
Color_Red = Color_Begin,
Color_Orange,
Color_Yellow,
Color_Green,
Color_Blue,
Color_Indigo,
Color_Violet,
Color_End
};
void foo(Color c)
{
}
void iterateColors()
{
for (size_t colorIdx = Color_Begin; colorIdx != Color_End; ++colorIdx)
{
foo(static_cast<Color>(colorIdx));
}
}
Расширяя сказанное Конрадом, одна возможная идиома в случае «генерировать код для каждой итерации» - использовать включенный файл для представления перечисления:
mystuff.h:
#ifndef LAST_ENUM_ELEMENT
#define LAST_ENUM_ELEMENT(ARG) ENUM_ELEMENT(ARG)
#endif
ENUM_ELEMENT(foo)
ENUM_ELEMENT(bar)
LAST_ENUM_ELEMENT(baz)
// not essential, but most likely every "caller" should do it anyway...
#undef LAST_ENUM_ELEMENT
#undef ENUM_ELEMENT
enum.h:
// include guard goes here (but mystuff.h doesn't have one)
enum element {
#define ENUM_ELEMENT(ARG) ARG,
#define LAST_ENUM_ELEMENT(ARG) ARG
#include "mystuff.h"
}
main.cpp:
#include "enum.h"
#define ENUM_ELEMENT(ARG) void do_##ARG();
#include "mystuff.h"
element value = getValue();
switch(value) {
#define ENUM_ELEMENT(ARG) case ARG: do_##ARG(); break;
#include "mystuff.h"
default: std::terminate();
}
Итак, чтобы добавить новый элемент «qux», вы добавляете его в mystuff.h и пишете do_qux функция. Вам не нужно касаться кода отправки.
Конечно, если значения в вашем перечислении должны быть конкретными непоследовательными целыми числами,
Мне это кажется хакерским, но может соответствовать вашим целям:
enum Blah {
FOO,
BAR,
NUM_BLAHS
};
// later on
for (int i = 0; i < NUM_BLAHS; ++i) {
switch (i) {
case FOO:
// foo stuff
break;
case BAR:
// bar stuff
break;
default:
// you're missing a case statement
}
}
Если вам нужно специальное начальное значение, вы можете сделать его константой и установить в своем перечислении. Я не проверял, компилируется ли это, но должно быть близко :-). Надеюсь, это поможет.
Я думаю, что этот подход может быть хорошим балансом для вашего варианта использования. Используйте его, если вам не нужно делать это для множества разных перечислимых типов и вы не хотите иметь дело с препроцессором. Просто обязательно прокомментируйте и, возможно, добавьте TODO, чтобы позже изменить его на что-то лучшее: -).
Нет
Однако вы можете определить свой собственный класс, который реализует перечислимые функции с итерациями. Вы можете вспомнить трюк из дней до 1.5 Java, названный «шаблон проектирования типобезопасного перечисления». Вы можете сделать эквивалент C ++.
Ни то, ни другое невозможно без небольшого ручного труда. Если вы хотите вникнуть в эту область, большую часть работы можно выполнить с помощью макросов.
Вы можете выполнить некоторые из предложенных методов выполнения статически с помощью TMP.
#include <iostream>
enum abc
{
a,
b,
c,
end
};
void function_call(abc val)
{
std::cout << val << std::endl;
}
template<abc val>
struct iterator_t
{
static void run()
{
function_call(val);
iterator_t<static_cast<abc>(val + 1)>::run();
}
};
template<>
struct iterator_t<end>
{
static void run()
{
}
};
int main()
{
iterator_t<a>::run();
return 0;
}
Вывод этой программы:
0
1
2
Хорошее описание этой техники см. в гл. 1 книги Abrahams, Gurtovoy "C++ Template Metaprogramming". Преимущество этого способа по сравнению с предлагаемыми техниками времени выполнения состоит в том, что при оптимизации этого кода он может инлайнить статику и примерно эквивалентен:
function_call(a);
function_call(b);
function_call(c);
Инлайн function_call для еще большей помощи компилятора.
Здесь применима та же критика, что и к другим техникам итерации перечислений. Эта техника работает только в том случае, если ваше перечисление непрерывно увеличивается от а до конца на единицы.