ฉันจะวนซ้ำ enum ได้อย่างไร

ฉันเพิ่งสังเกตเห็นว่าคุณไม่สามารถใช้ตัวดำเนินการทางคณิตศาสตร์มาตรฐานกับ enum เช่น ++ หรือ + =

ดังนั้นวิธีที่ดีที่สุดในการวนซ้ำผ่านค่าทั้งหมดใน C ++ enum คืออะไร

วิธีทั่วไปมีดังนี้:

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

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

โปรดทราบว่าค่า Enum Lastนั้นจะถูกข้ามโดยการทำซ้ำ การใช้Lastenum "ปลอม" นี้คุณไม่จำเป็นต้องอัปเดตเงื่อนไขการยกเลิกของคุณในการวนซ้ำไปยัง enum "ของจริง" ล่าสุดทุกครั้งที่คุณต้องการเพิ่ม enum ใหม่ หากคุณต้องการเพิ่ม enums เพิ่มเติมในภายหลังเพียงเพิ่มไว้ก่อนหน้า การวนซ้ำในตัวอย่างนี้จะยังคงใช้งานได้

แน่นอนนี้แบ่งลงถ้าระบุค่า enum:

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

นี่แสดงให้เห็นว่า enum ไม่ได้มีความตั้งใจที่จะทำซ้ำ วิธีทั่วไปในการจัดการกับ enum คือใช้ในคำสั่ง switch

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

หากคุณต้องการแจกแจงให้ระบุค่า enum ในเวกเตอร์แล้ววนซ้ำไปเรื่อย ๆ สิ่งนี้จะจัดการกับค่า 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;
}

ถ้า enum ของคุณเริ่มต้นด้วย 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 จะมีทางเลือกอื่น: การเขียน iterator แบบกำหนดเองอย่างง่าย

สมมติว่า enum ของคุณคือ

enum class foo {
  one,
  two,
  three
};

รหัสทั่วไปนี้จะทำเคล็ดลับค่อนข้างมีประสิทธิภาพ - วางในส่วนหัวทั่วไปมันจะให้บริการคุณสำหรับ enum ใด ๆ ที่คุณอาจต้องทำซ้ำมากกว่า:

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

จากนั้นคุณสามารถวนซ้ำโดยใช้ช่วงสำหรับ

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

สมมติฐานที่ว่าคุณไม่มีช่องว่างใน enum ของคุณยังคงเป็นจริง ไม่มีข้อสันนิษฐานเกี่ยวกับจำนวนบิตที่จำเป็นจริง ๆ ในการจัดเก็บค่า enum (ขอบคุณ std :: รากฐาน _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))
    {}

คุณไม่สามารถใช้ Enum ได้ บางที Enum อาจไม่เหมาะกับสถานการณ์ของคุณมากที่สุด

หลักการทั่วไปคือตั้งชื่อค่า enum ล่าสุดเช่น 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;
    }

มันสามารถใช้ในการวนซ้ำไปข้างหลังและไปข้างหน้าผ่านไม่ได้ลงนาม, จำนวนเต็ม, enums และตัวอักษร:

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


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

แม้จะมีคำจำกัดความที่ไม่เหมาะสม ฉันดู disassembler ใน 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 นั้นถูกเรียงลำดับตามลำดับนั้นเกิดข้อผิดพลาดได้ง่าย นอกจากนี้คุณอาจต้องการวนซ้ำตัวแจงนับที่เลือกเท่านั้น หากเซ็ตย่อยนั้นมีขนาดเล็กวนซ้ำอย่างชัดเจนอาจเป็นทางเลือกที่หรูหรา:

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

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

หากคุณไม่ชอบที่จะสร้างมลพิษให้คุณ enum ด้วยรายการ 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);
}

นี่เป็นอีกวิธีการหนึ่งที่ใช้งานได้สำหรับ enums ที่ต่อเนื่องกันเท่านั้น มันให้การคาดคะเนซ้ำยกเว้นความอัปลักษณ์ที่เพิ่มขึ้นซึ่งเป็นที่ที่มันเป็นเพราะนั่นคือสิ่งที่แตกใน 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 ค่าถูกใส่ไว้ในหน่วยความจำ) ค่าจาก enum ที่ไม่ต่อเนื่องใน [หนึ่งกรณี | https://godbolt.org/z/XuGtoc] ฉันสงสัยว่าพฤติกรรมแปลก ๆ นี้เกิดจากการวิเคราะห์พฤติกรรมเชิงลึกเกี่ยวกับแคชและการทำนายสาขา

นี่คือลิงค์ไปยังการทดสอบซ้ำอย่างง่าย ๆ ใน godboltที่แสดงให้เห็นถึงอาร์เรย์ที่ไม่ได้รับการสร้างอินสแตนซ์เสมอไป

ราคาของเทคนิคนี้กำลังเขียนองค์ประกอบ enum สองครั้งและทำให้ทั้งสองรายการสอดคล้องกัน

ใน Bjarne Stroustrup ของการเขียนโปรแกรมภาษา C ++ หนังสือภาษาคุณสามารถอ่านที่เขาเสนอให้เกินพิกัดสำหรับคุณโดยเฉพาะoperator++ ประเภทที่ผู้ใช้กำหนดเองและโอเปอเรเตอร์การบรรทุกเกินพิกัดมีอยู่ในภาษาสำหรับสถานการณ์เฉพาะเหล่านี้enumenum

คุณจะสามารถรหัสต่อไปนี้:

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

หมายเหตุ: นี่เป็นโค้ดที่น้อยกว่าคำตอบ iterator ที่กำหนดเองอย่างง่าย templatized

คุณสามารถทำให้มันใช้งานได้กับ 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 คือ:

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

สิ่งนี้ไม่ทำลายลงไม่ว่า ints ในการแสดงตราบใดที่การตรวจสอบ -1 ไม่ชนกับหนึ่งในองค์ประกอบของหลักสูตร