Як я можу повторити перелік?

Я щойно помітив, що ти не можеш використовувати стандартних математичних операторів на enum, такий як ++ або + =

Отже, який найкращий спосіб перебрати всі значення в перерахунку C ++?

Типовий спосіб такий:

enum Foo {
  One,
  Two,
  Three,
  Last
};

for ( int fooInt = One; fooInt != Last; fooInt++ )
{
   Foo foo = static_cast<Foo>(fooInt);
   // ...
}

Зверніть увагу, що перерахунок Lastпризначений для пропускання ітерацією. Використовуючи цей "підроблений" Lastперелік, вам не доведеться оновлювати свою завершальну умову в циклі for до останнього "справжнього" перерахунку щоразу, коли ви бажаєте додати нове перерахування. Якщо ви хочете додати більше перерахунків пізніше, просто додайте їх до Last. Цикл у цьому прикладі все одно буде працювати.

Звичайно, це руйнується, якщо вказані значення перерахунків:

enum Foo {
  One = 1,
  Two = 9,
  Three = 4,
  Last
};

Це ілюструє, що перерахунок насправді не призначений для перебору через. Типовий спосіб поводження з перерахунком - це використовувати його в операторі переключення.

switch ( foo )
{
    case One:
        // ..
        break;
    case Two:  // intentional fall-through
    case Three:
        // ..
        break;
    case Four:
        // ..
        break;
     default:
        assert( ! "Invalid Foo enum value" );
        break;
}

Якщо ви дійсно хочете перерахувати, введіть значення перерахунку у вектор і повторіть це. Це також буде належним чином відповідати заданим значенням enum.

#include <iostream>
#include <algorithm>

namespace MyEnum
{
  enum Type
  {
    a = 100,
    b = 220,
    c = -1
  };

  static const Type All[] = { a, b, c };
}

void fun( const MyEnum::Type e )
{
  std::cout << e << std::endl;
}

int main()
{
  // all
  for ( const auto e : MyEnum::All )
    fun( e );

  // some
  for ( const auto e : { MyEnum::a, MyEnum::b } )
    fun( e );

  // all
  std::for_each( std::begin( MyEnum::All ), std::end( MyEnum::All ), fun );

  return 0;
}

Якщо ваш перерахунок починається з 0, а приріст завжди дорівнює 1.

enum enumType 
{ 
    A = 0,
    B,
    C,
    enumTypeEnd
};

for(int i=0; i<enumTypeEnd; i++)
{
   enumType eCurrent = (enumType) i;            
}

Якщо ні, я здогадуюсь, єдине, чому це створити щось на зразок

vector<enumType> vEnums;

додайте елементи та використовуйте звичайні ітератори ....

З c ++ 11 насправді існує альтернатива: написання простого шаблонованого користувальницького ітератора.

припустимо, що ваш перерахунок є

enum class foo {
  one,
  two,
  three
};

Цей загальний код зробить трюк досить ефективно - розмістіть у загальному заголовку, він послужить вам для будь-якої перерахунку, який, можливо, знадобиться повторити:

#include <type_traits>
template < typename C, C beginVal, C endVal>
class Iterator {
  typedef typename std::underlying_type<C>::type val_t;
  int val;
public:
  Iterator(const C & f) : val(static_cast<val_t>(f)) {}
  Iterator() : val(static_cast<val_t>(beginVal)) {}
  Iterator operator++() {
    ++val;
    return *this;
  }
  C operator*() { return static_cast<C>(val); }
  Iterator begin() { return *this; } //default ctor is good
  Iterator end() {
      static const Iterator endIter=++Iterator(endVal); // cache it
      return endIter;
  }
  bool operator!=(const Iterator& i) { return val != i.val; }
};

Вам потрібно буде спеціалізуватися

typedef Iterator<foo, foo::one, foo::three> fooIterator;

І тоді ви можете повторити, використовуючи range-for

for (foo i : fooIterator() ) { //notice the parentheses!
   do_stuff(i);
}

Припущення, що у вас немає прогалин у вашій перерахунку, все ще вірно; немає припущення щодо кількості бітів, фактично необхідних для зберігання значення enum (завдяки std :: underlying_type)

занадто складне це рішення, я роблю таке:

enum NodePosition { Primary = 0, Secondary = 1, Tertiary = 2, Quaternary = 3};

const NodePosition NodePositionVector[] = { Primary, Secondary, Tertiary, Quaternary };

for (NodePosition pos : NodePositionVector) {
...
}

Я часто роблю це так

    enum EMyEnum
    {
        E_First,
        E_Orange = E_First,
        E_Green,
        E_White,
        E_Blue,
        E_Last
    }

    for (EMyEnum i = E_First; i < E_Last; i = EMyEnum(i + 1))
    {}

або якщо не послідовно, але з регулярним кроком (наприклад, бітові прапори)

    enum EAnimalCaps
    {
        E_First,
        E_None    = E_First,
        E_CanFly  = 0x1,
        E_CanWalk = 0x2
        E_CanSwim = 0x4,
        E_Last
    }

    class MyAnimal
    {
       EAnimalCaps m_Caps;
    }

    class Frog
    {
        Frog() : 
            m_Caps(EAnimalCaps(E_CanWalk | E_CanSwim))
        {}
    }

    for (EAnimalCaps= E_First; i < E_Last; i = EAnimalCaps(i << 1))
    {}

Не можна з перерахунком. Можливо, перерахунок не найкраще підходить для вашої ситуації.

Загальна умова - називати останнє значення перерахунку чимось на зразок MAX і використовувати це для керування циклом за допомогою int.

Щось, що не було висвітлено в інших відповідях = якщо ви використовуєте сильно набрані C ++ 11 перерахунки, ви не можете їх використовувати ++або використовувати + intїх. У цьому випадку потрібно трохи месіє рішення:

enum class myenumtype {
  MYENUM_FIRST,
  MYENUM_OTHER,
  MYENUM_LAST
}

for(myenumtype myenum = myenumtype::MYENUM_FIRST;
    myenum != myenumtype::MYENUM_LAST;
    myenum = static_cast<myenumtype>(static_cast<int>(myenum) + 1)) {

  do_whatever(myenum)

}

Ви можете спробувати визначити такий макрос:

#define for_range(_type, _param, _A1, _B1) for (bool _ok = true; _ok;)\
for (_type _start = _A1, _finish = _B1; _ok;)\
    for (int _step = 2*(((int)_finish)>(int)_start)-1;_ok;)\
         for (_type _param = _start; _ok ; \
 (_param != _finish ? \
           _param = static_cast<_type>(((int)_param)+_step) : _ok = false))

Тепер ви можете використовувати його:

enum Count { zero, one, two, three }; 

    for_range (Count, c, zero, three)
    {
        cout << "forward: " << c << endl;
    }

Він може використовуватися для повторення назад і вперед за допомогою безпідписаних цілих чисел, перерахунків і знаків:

for_range (unsigned, i, 10,0)
{
    cout << "backwards i: " << i << endl;
}


for_range (char, c, 'z','a')
{
    cout << c << endl;
}

Незважаючи на незручне визначення, він оптимізований дуже добре. Я подивився на розбиральник у VC ++. Код надзвичайно ефективний. Не слід відкладати, а три для заяви: компілятор буде виробляти лише один цикл після оптимізації! Ви навіть можете визначити вкладені петлі:

unsigned p[4][5];

for_range (Count, i, zero,three)
    for_range(unsigned int, j, 4, 0)
    {   
        p[i][j] = static_cast<unsigned>(i)+j;
    }

Ви, очевидно, не можете повторити перелічені типи з пробілами.

Ви також можете перевантажувати оператори збільшення / зменшення для перерахованого типу.

Якщо припустити, що перерахунок нумерується послідовно, схильний до помилок. Більше того, ви можете повторити лише вибрані перелічувачі. Якщо цей підмножина невеликий, чітко переглядаючи його, можливо, це буде елегантним вибором:

enum Item { Man, Wolf, Goat, Cabbage }; // or enum class

for (auto item : {Wolf, Goat, Cabbage}) { // or Item::Wolf, ...
    // ...
}

Якщо вам не подобається забруднювати перерахунок остаточним елементом COUNT (тому, що, можливо, якщо ви також використовуєте enum в комутаторі, тоді компілятор попередить вас про відсутній випадок COUNT :), ви можете зробити це:

enum Colour {Red, Green, Blue};
const Colour LastColour = Blue;

Colour co(0);
while (true) {
  // do stuff with co
  // ...
  if (co == LastColour) break;
  co = Colour(co+1);
}

Ось ще одне рішення, яке працює лише для суміжних перерахунків. Це дає очікувану ітерацію, за винятком потворності з приростом, куди він належить, оскільки саме це порушено в C ++.

enum Bar {
    One = 1,
    Two,
    Three,
    End_Bar // Marker for end of enum; 
};

for (Bar foo = One; foo < End_Bar; foo = Bar(foo + 1))
{
    // ...
}

enum class A {
    a0=0, a3=3, a4=4
};
constexpr std::array<A, 3> ALL_A {A::a0, A::a3, A::a4}; // constexpr is important here

for(A a: ALL_A) {
  if(a==A::a0 || a==A::a4) std::cout << static_cast<int>(a);
}

A constexpr std::arrayможе повторювати навіть непослідовні перерахунки, без компілятора інстанціювати масив. Це залежить від речей, таких як евристика оптимізації компілятора та від того, чи приймете ви адресу адреси масиву.

У своїх експериментах я виявив, що g++9.1 з -O3оптимізує поданий вище масив, якщо є 2 непослідовні значення або досить багато послідовних значень (я перевірив до 6). Але це робиться лише в тому випадку, якщо у вас є ifзаява. (Я спробував твердження, що порівнював ціле значення, що перевищує всі елементи послідовного масиву, і він підкреслював ітерацію, незважаючи на те, що ніхто не був виключений, але коли я випустив оператор if, ці значення було введено в пам'ять.) значення з непослідовного перерахунку в [одному випадку | https://godbolt.org/z/XuGtoc] . Я підозрюю, що така дивна поведінка пов'язана з глибокою евристикою, пов’язаною з кешами та прогнозуванням гілок.

Ось посилання на просту ітерацію тесту на godbolt, яка демонструє масив, не завжди отримується екземпляром.

Ціною цієї техніки є написання елементів enum двічі та синхронізація двох списків.

У книзі мов програмування Bjarne Stroustrup на C ++ ви можете прочитати, що він пропонує перевантажити operator++для вашого конкретного enum. enum- це визначені користувачем типи, і оператор перевантаження існує мовою для цих конкретних ситуацій.

Ви зможете кодувати таке:

#include <iostream>
enum class Colors{red, green, blue};
Colors& operator++(Colors &c, int)
{
     switch(c)
     {
           case Colors::red:
               return c=Colors::green;
           case Colors::green:
               return c=Colors::blue;
           case Colors::blue:
               return c=Colors::red; // managing overflow
           default:
               throw std::exception(); // or do anything else to manage the error...
     }
}

int main()
{
    Colors c = Colors::red;
    // casting in int just for convenience of output. 
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    std::cout << (int)c++ << std::endl;
    return 0;
}

код тесту: http://cpp.sh/357gb

Майте на увазі, що я використовую enum class. Код також добре працює enum. Але я вважаю за краще, enum classоскільки вони сильно набрані і можуть заважати нам помилятися під час компіляції.

Для компіляторів MS:

#define inc_enum(i) ((decltype(i)) ((int)i + 1))

enum enumtype { one, two, three, count};
for(enumtype i = one; i < count; i = inc_enum(i))
{ 
    dostuff(i); 
}

Примітка: це набагато менше коду, ніж простий шаблонований відповідь користувальницького ітератора.

Ви можете домогтися цього для роботи з GCC, використовуючи typeofзамість цього decltype, але в даний момент у мене немає компілятора, щоб переконатися, що він компілюється.

typedef enum{
    first = 2,
    second = 6,
    third = 17
}MyEnum;

static const int enumItems[] = {
    first,
    second,
    third
}

static const int EnumLength = sizeof(enumItems) / sizeof(int);

for(int i = 0; i < EnumLength; i++){
    //Do something with enumItems[i]
}

У C ++ немає інтроспекції, тому ви не можете визначити подібну річ під час виконання.

Якби ви знали, що значення enum є послідовними, наприклад, Qt: Key enum, ви можете:

Qt::Key shortcut_key = Qt::Key_0;
for (int idx = 0; etc...) {
    ....
    if (shortcut_key <= Qt::Key_9) {
        fileMenu->addAction("abc", this, SLOT(onNewTab()),
                            QKeySequence(Qt::CTRL + shortcut_key));
        shortcut_key = (Qt::Key) (shortcut_key + 1);
    }
}

Це працює як очікувалося.

Просто зробіть масив ints та циклічні масиви над масивом, але змусьте останній елемент сказати -1 і використовувати його для умови виходу.

Якщо перелік:

enum MyEnumType{Hay=12,Grass=42,Beer=39};

потім створіть масив:

int Array[] = {Hay,Grass,Beer,-1};

for (int h = 0; Array[h] != -1; h++){
  doStuff( (MyEnumType) Array[h] );
}

Це не розбивається незалежно від вкладень у поданні до тих пір, поки -1 перевірка не зіткнеться з одним із елементів курсу.