web-dev-qa-db-ja.com

列挙型クラスで範囲ベースのForを許可しますか？

enum classのすべてのメンバーをループするコードの繰り返しチャンクがあります。

現在使用しているforループは、新しいrange-based forと比較すると非常に見た目が悪いです。

現在のforループの冗長性を削減するために、新しいC++ 11機能を利用する方法はありますか？

私が改善したい現在のコード：

enum class COLOR
{
    Blue,
    Red,
    Green,
    Purple,
    First=Blue,
    Last=Purple
};

inline COLOR operator++( COLOR& x ) { return x = (COLOR)(((int)(x) + 1)); }

int main(int argc, char** argv)
{
  // any way to improve the next line with range-based for?
  for( COLOR c=COLOR::First; c!=COLOR::Last; ++c )
  {
    // do work
  }
  return 0;
}

言い換えると、次のようなことができたらいいですね。

for( const auto& c : COLOR )
{
  // do work
}
c++for-loopc++11enums
65
kfmfe04

列挙型自体を反復子として列挙型を反復することは悪い考えであり、deft_codeの答えのように実際の反復子を使用することをお勧めします。しかし、これが本当にあなたが望むものなら：

COLOR operator++(COLOR& x) {
    return x = (COLOR)(std::underlying_type<COLOR>::type(x) + 1); 
}

COLOR operator*(COLOR c) {
    return c;
}

COLOR begin(COLOR r) {
    return COLOR::First;
}

COLOR end(COLOR r) {
    COLOR l=COLOR::Last;
    return ++l;
}

int main() { 
    //note the parenthesis after COLOR to make an instance
    for(const auto& c : COLOR()) {
        //do work
    }
    return 0;
}

ここでの作業： http://ideone.com/cyTGD8

extern const COLOR COLORS[(int)COLOR::Last+1];
const COLOR COLORS[] = {COLOR::Blue, COLOR::Red, COLOR::Green, COLOR::Purple};

int main() { 
    for(const auto& c : COLORS) {
        //do work
    }
    return 0;
}

ここに見られるように： http://ideone.com/9XadVt

（配列の個別の宣言と定義により、色の数が配列内の要素の数と一致しない場合、コンパイラエラーになります。優れた簡単な安全性チェック。）

30
Mooing Duck

個人的には、列挙型の++演算子をオーバーロードするのは好きではありません。多くの場合、増分 enum値は実際には意味がありません。本当に必要なのは、列挙型を反復処理する方法だけです。

以下は、反復をサポートする一般的なEnumクラスです。機能的ですが、不完全です。実際の実装は、コンストラクターへのアクセスを制限し、すべてのイテレーター特性を追加するのに適しています。

#include <iostream>

template< typename T >
class Enum
{
public:
   class Iterator
   {
   public:
      Iterator( int value ) :
         m_value( value )
      { }

      T operator*( void ) const
      {
         return (T)m_value;
      }

      void operator++( void )
      {
         ++m_value;
      }

      bool operator!=( Iterator rhs )
      {
         return m_value != rhs.m_value;
      }

   private:
      int m_value;
   };

};

template< typename T >
typename Enum<T>::Iterator begin( Enum<T> )
{
   return typename Enum<T>::Iterator( (int)T::First );
}

template< typename T >
typename Enum<T>::Iterator end( Enum<T> )
{
   return typename Enum<T>::Iterator( ((int)T::Last) + 1 );
}

enum class Color
{
   Red,
   Green,
   Blue,
   First = Red,
   Last = Blue
};

int main()
{
   for( auto e: Enum<Color>() )
   {
      std::cout << ((int)e) << std::endl;
   }
}
49
deft_code
enum class Color {
    blue,
    red,
    green = 5,
    purple
};
const std::array<Color,4> all_colors = {Color::blue, Color::red, Color::green, Color::purple};

次に：

for (Color c : all_colors) {
    //...
}

多くの場合、「なし」の値が必要なこのように使用します：

// Color of a piece on a chess board
enum class Color {
    white,
    black,
    none
};
const std::array<Color,3> colors = {Color::white, Color::black};

template <typename CONTAINER>
bool has_item (CONTAINER const & c, typename CONTAINER::const_reference v) {
    return std::find(c.begin(), c.end(), v) != c.end();
}

bool is_valid (Color c) {
    return has_item(colors, c) || c == Color::none;
}

bool do_it (Color c) {
    assert(has_item(colors, c)); // here I want a real color, not none
    // ...
}

bool stop_it (Color c) {
    assert(is_valid(c));         // but here I just want something valid
    // ...
}
33
user1594322

Boost :: mplを使用すると、おそらく賢いことができます。大まかなバージョンは次のようになります。

#include <typeinfo>

// ---------------------------------------------------------------------------|
// Boost MPL
// ---------------------------------------------------------------------------|
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/iterator_range.hpp>
#include <boost/mpl/range_c.hpp>

namespace mpl = boost::mpl;

using namespace std;

enum class COLOR 
{ 
   Blue,
   Red,
   Green,
   Purple,
   Last
};

struct enumValPrinter
{
    template< typename T >
    void operator() (const T&)
    {
        cout << "enumValPrinter with: " << typeid( T ).name() << " : " 
             << T::value << "\n";
    }
};

int main(int, char**)
{
    typedef mpl::range_c< int, static_cast<int>( COLOR::Blue ), 
                            static_cast<int>( COLOR::Last ) > Colors;
    mpl::for_each< Colors >( enumValPrinter() );
    return 0;
}
4
mark

テストした例（GCC 4.6.1）は次のとおりです。

enum class COLOR
{
    Blue,
    Red,
    Green,
    Purple,
    First=Blue,
    Last=Purple
};

COLOR operator++( COLOR& x ) { return x = (COLOR)(((int)(x) + 1)); }

COLOR operator*(COLOR c) {return c;}

COLOR begin(COLOR r) {return COLOR::First;}
// end iterator needs to return one past the end!
COLOR end(COLOR r)   {return COLOR(int(COLOR::Last) + 1);}


int main()
{
    for (const auto& color : COLOR()) std::cout << int(color); //0123
    return 0;
}
3
jrok

私はこのアイデアが大好きで、しばしばそれを望んでいます。

私が見る問題は、列挙型アイテムに繰り返し数値がある場合に何が起こるかです。上記のすべての実装では、整数型および++へのキャストが必要です。最終的には、すべての場合で各項目を完全に反復処理するには言語サポートが必要になると思います。これにはあまり反対しませんが、First、Last、またはBegin、Endを持つ必要はなくなります。コンテナのbegin（）end（）を探すようなものです。

enum class COLOR 
{
   Blue,
   Red,
   Green,
   Mauve = 0,
   Purple,
   Last
};

番号付けはMauveから始まります。

2
emsr

あなたがひどい人なら、プリプロセッサでこの動作を得ることができます：

#include <vector>
#include <cstdio>

#define ENUM_NAME COLOR
#define ENUM_VALUES \
    ENUM_VALUE(Blue) \
    ENUM_VALUE(Red) \
    ENUM_VALUE(Green) \
    ENUM_VALUE(Purple)

// This block would be a #include "make_iterable_enum.h"
#define ENUM_VALUE(v) v,
enum class ENUM_NAME {ENUM_VALUES};
#undef ENUM_VALUE
#define ENUM_VALUE(v) ENUM_NAME::v,
#define VECTOR_NAME(v) values_ ## v
#define EXPAND_TO_VECTOR_NAME(v) VECTOR_NAME(v)
const std::vector<ENUM_NAME> EXPAND_TO_VECTOR_NAME(ENUM_NAME){ENUM_VALUES};
#undef ENUM_VALUE
#undef ENUM_NAME
#undef ENUM_VALUES
#undef VECTOR_NAME
#undef EXPAND_TO_VECTOR_NAME
// end #included block

int main() {
    for (auto v : COLOR_values) {
        printf("%d\n", (int)v);
    }
}

マイナーな修正を加えると、これもサポートできます。 ENUM_SETVALUE（Blue、4）およびconstマップの作成（例： COLOR :: Blueから「Blue」。およびその逆。

私は標準がこれらの機能を列挙クラスのオプションとして組み込んだことを望みます。回避策はありません。

2
Raven Black

C++ initializer_listのメンバーを反復処理できると確信しているので、過去にこれを実行したことがあると考えています。

enum class Color {Red, Green, Blue};

for (const Color c : {Color::Red, Color::Green, Color::Blue})
{
}

これに問題があるかどうかはわかりませんが、簡潔であるとお勧めしますが、色が多い場合は理想的ではありません。

2
Coder_Dan

列挙型のインクリメントを承認するかどうかは、役に立つ場合があります。そのための簡単な方法を次に示します。

enum class COLOR
{
    Blue,
    Red,
    Green,
    Purple,
    First=Blue,
    Last=Purple
};

COLOR c;

++( *reinterpret_cast<int*>( &c));

コンパイラーがキャストと逆参照を処理するため、オーバーヘッドはありません。必要に応じて、範囲チェックまたはその他の機能を追加します。

2
rm1948