Làm thế nào tôi có thể lặp đi lặp lại một enum?

Tôi chỉ nhận thấy rằng bạn không thể sử dụng các toán tử toán học tiêu chuẩn trên một enum như ++ hoặc + =

Vì vậy, cách tốt nhất để lặp qua tất cả các giá trị trong một enum C ++ là gì?

Cách điển hình như sau:

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

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

Xin lưu ý, enum Last có nghĩa là được bỏ qua bởi phép lặp. Sử dụng Lastenum "giả" này , bạn không phải cập nhật điều kiện kết thúc của mình trong vòng lặp for thành enum "thực" cuối cùng mỗi khi bạn muốn thêm một enum mới. Nếu bạn muốn thêm nhiều enums sau, chỉ cần thêm chúng trước Last. Vòng lặp trong ví dụ này vẫn sẽ hoạt động.

Tất nhiên, điều này bị phá vỡ nếu các giá trị enum được chỉ định:

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

Điều này minh họa rằng một enum không thực sự có nghĩa là lặp đi lặp lại. Cách điển hình để đối phó với một enum là sử dụng nó trong câu lệnh switch.

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

Nếu bạn thực sự muốn liệt kê, nhét các giá trị enum vào một vectơ và lặp lại trên đó. Điều này cũng sẽ giải quyết đúng với các giá trị enum được chỉ định.

#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;
}

Nếu enum của bạn bắt đầu bằng 0 và mức tăng luôn là 1.

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

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

Nếu không tôi đoán lý do duy nhất là tạo ra một cái gì đó như một

vector<enumType> vEnums;

thêm các mục và sử dụng các trình vòng lặp bình thường ....

Với c ++ 11, thực sự có một cách khác: viết một trình lặp tùy chỉnh templatized đơn giản.

giả sử enum của bạn là

enum class foo {
  one,
  two,
  three
};

Mã chung này sẽ thực hiện thủ thuật, khá hiệu quả - đặt trong một tiêu đề chung, nó sẽ phục vụ bạn cho bất kỳ enum nào bạn có thể cần lặp lại:

#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; }
};

Bạn sẽ cần phải chuyên môn hóa nó

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

Và sau đó bạn có thể lặp lại bằng cách sử dụng phạm vi cho

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

Giả định rằng bạn không có khoảng trống trong enum của bạn vẫn đúng; không có giả định về số lượng bit thực sự cần thiết để lưu trữ giá trị enum (nhờ std :: ngầm_type)

quá nhiều giải pháp phức tạp, tôi làm như thế:

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

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

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

Tôi thường làm như thế

    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))
    {}

hoặc nếu không liên tiếp, nhưng với bước thông thường (ví dụ: cờ bit)

    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))
    {}

Bạn không thể với một enum. Có lẽ một enum không phù hợp nhất cho tình huống của bạn.

Một quy ước chung là đặt tên giá trị enum cuối cùng giống như MAX và sử dụng giá trị đó để điều khiển vòng lặp bằng int.

Một cái gì đó chưa được đề cập trong các câu trả lời khác = nếu bạn đang sử dụng các enum C ++ 11 được gõ mạnh, bạn không thể sử dụng ++hoặc sử dụng + intchúng. Trong trường hợp đó, một chút giải pháp lộn xộn là bắt buộc:

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)

}

Bạn có thể thử và xác định macro sau:

#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))

Bây giờ bạn có thể sử dụng nó:

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

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

Nó có thể được sử dụng để lặp đi lặp lại và chuyển tiếp thông qua không dấu, số nguyên, enums và ký tự:

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


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

Mặc dù định nghĩa vụng về của nó, nó được tối ưu hóa rất tốt. Tôi đã xem xét trình dịch ngược trong VC ++. Mã cực kỳ hiệu quả. Đừng bỏ qua nhưng ba câu lệnh: trình biên dịch sẽ chỉ tạo một vòng lặp sau khi tối ưu hóa! Bạn thậm chí có thể định nghĩa các vòng lặp kèm theo:

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;
    }

Bạn rõ ràng không thể lặp qua các kiểu liệt kê với các khoảng trống.

Bạn cũng có thể quá tải các toán tử tăng / giảm cho loại liệt kê của bạn.

Giả sử enum được đánh số liên tục là dễ bị lỗi. Hơn nữa, bạn có thể chỉ muốn lặp lại các điều tra viên được chọn. Nếu tập hợp con đó nhỏ, việc lặp lại nó rõ ràng có thể là một lựa chọn tao nhã:

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

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

Nếu bạn không muốn làm ô nhiễm enum của bạn với một mục COUNT cuối cùng (bởi vì có thể nếu bạn cũng sử dụng enum trong một công tắc thì trình biên dịch sẽ cảnh báo bạn về trường hợp bị thiếu COUNT :), bạn có thể làm điều này:

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);
}

Đây là một giải pháp khác chỉ hoạt động cho các enum tiếp giáp. Nó mang lại sự lặp lại dự kiến, ngoại trừ sự xấu xí trong gia số, đó là nơi nó thuộc về, vì đó là những gì bị phá vỡ trong 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);
}

Một constexpr std::array có thể lặp lại ngay cả các enum không tuần tự mà không có mảng được trình biên dịch khởi tạo. Điều này phụ thuộc vào những thứ như heuristic tối ưu hóa của trình biên dịch và liệu bạn có lấy địa chỉ của mảng không.

Trong các thử nghiệm của tôi, tôi thấy rằng g++9.1 với -O3sẽ tối ưu hóa mảng trên nếu có 2 giá trị không tuần tự hoặc khá nhiều giá trị tuần tự (tôi đã thử nghiệm lên đến 6). Nhưng nó chỉ làm điều này nếu bạn có một iftuyên bố. . các giá trị từ một enum không tuần tự trong [một trường hợp | https://godbolt.org/z/XuGtoc] . Tôi nghi ngờ hành vi kỳ quặc này là do heuristic sâu phải làm với bộ nhớ cache và dự đoán chi nhánh.

Đây là một liên kết đến một phép lặp thử nghiệm đơn giản trên godbolt để chứng minh rằng mảng không phải lúc nào cũng được khởi tạo.

Giá của kỹ thuật này là viết các phần tử enum hai lần và giữ hai danh sách đồng bộ.

Trong cuốn sách ngôn ngữ lập trình C ++ của Bjarne Stroustrup, bạn có thể đọc rằng anh ta đang đề xuất quá tải operator++cho cụ thể của bạn enum. enumlà các loại do người dùng định nghĩa và toán tử nạp chồng tồn tại trong ngôn ngữ cho các tình huống cụ thể này.

Bạn sẽ có thể mã như sau:

#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;
}

mã kiểm tra: http://cpp.sh/357gb

Tâm trí tôi đang sử dụng enum class. Mã cũng hoạt động tốt với enum. Nhưng tôi thích enum classvì chúng được gõ mạnh và có thể ngăn chúng tôi mắc lỗi vào thời gian biên dịch.

Đối với trình biên dịch 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); 
}

Lưu ý: đây là mã ít hơn nhiều so với câu trả lời lặp tùy chỉnh templatized đơn giản.

Bạn có thể làm cho nó hoạt động với GCC bằng cách sử dụng typeofthay vì decltype, nhưng tôi không có trình biên dịch đó tiện dụng vào lúc này để đảm bảo nó biên dịch.

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 ++ không có nội tâm, vì vậy bạn không thể xác định loại điều này vào thời gian chạy.

Nếu bạn biết rằng các giá trị enum là tuần tự, ví dụ như ent Qt: Key, bạn có thể:

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);
    }
}

Nó hoạt động như mong đợi.

Chỉ cần tạo một mảng ints và lặp qua mảng, nhưng làm cho phần tử cuối cùng nói -1 và sử dụng nó cho điều kiện thoát.

Nếu enum là:

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

sau đó tạo mảng:

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

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

Điều này không bị phá vỡ cho dù các số nguyên trong biểu diễn miễn là kiểm tra -1 không va chạm với một trong các yếu tố của khóa học.