C ++で列挙型を列挙する
C++では、列挙型（ランタイムまたはコンパイル時（推奨）のいずれか）を列挙して関数を呼び出し、反復ごとにコードを生成することは可能ですか？
使用例：
enum abc
{
start
a,
b,
c,
end
}
for each (__enum__member__ in abc)
{
function_call(__enum__member__);
}
もっともらしい複製：
@ StackedCrooked回答に追加するには、operator++、operator--およびoperator*をオーバーロードして、イテレータのような機能を使用できます。
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;
}
いくつかの<algorithm>テンプレートでテストしてみましょう
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));
}
}
どちらも少し手作業なしでは不可能です。その領域を詳しく調べたい場合は、多くの作業をマクロで行うことができます。
Konradの発言を拡張すると、「反復ごとにコードを生成する」場合の1つの可能なイディオムは、含まれているファイルを使用して列挙を表すことです。
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_ELEMENT(foo)...リストを個別に維持することになり、これは面倒です。
私は通常、次のようにします。
enum abc
{
abc_begin,
a = abc_begin,
b,
c,
abc_end
};
void foo()
{
for( auto&& r : range(abc_begin,abc_end) )
{
cout << r;
}
}
rangeは完全に汎用的で、次のように定義されています。
template <typename T>
class Range
{
public:
Range( const T& beg, const T& end ) : b(beg), e(end) {}
struct iterator
{
T val;
T operator*() { return val; }
iterator& operator++() { val = (T)( 1+val ); return *this; }
bool operator!=(const iterator& i2) { return val != i2.val; }
};
iterator begin() const { return{b}; }
iterator end() const { return{e}; }
private:
const T& b;
const T& e;
};
template <typename T>
Range<T> range( const T& beg, const T& end ) { return Range<T>(beg,end); }
番号
ただし、列挙型の機能を反復で実装する独自のクラスを定義することもできます。 1.5より前のJava日、「タイプセーフなenum設計パターン」と呼ばれる）のトリックを思い出すかもしれません。C++で同等のことができます。
これは私には奇抜なようですが、あなたの目的に合うかもしれません：
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を追加して、後でそれをより良いものに変更します:-)。
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
この手法の適切な扱い方については、GurtovoyのAbrahamsの1章「C++テンプレートメタプログラミング」を参照してください。提案されたランタイムテクニックに対してこの方法でこれを行うことの利点は、このコードを最適化すると、静的要素をインライン化でき、おおよそ次のようになることです。
function_call(a);
function_call(b);
function_call(c);
コンパイラーからさらにヘルプを得るには、インラインfunction_call。
他の列挙反復手法に対する同じ批判がここでも当てはまります。この手法は、列挙が最後から最後まで連続して1ずつ増加する場合にのみ機能します。
テンプレートが大好きですが、私はこれを将来/他の人々の使用法のために書き留めておきますので、上記のいずれかで失われることはありません。
列挙型は、既知の順序付けされた方法で物事を比較するために便利です。これらは通常、整数値を読みやすくするために、関数にハードコードされて使用されます。プリプロセッサの定義と多少似ていますが、リテラルに置き換えられず、実行時に保持およびアクセスされる点が異なります。
Htmlエラーコードを定義する列挙型があり、500年代のエラーコードがサーバーエラーであることがわかっている場合は、次のようなコードを読むほうがよいでしょう。
enum HtmlCodes {CONTINUE_CODE=100,CLIENT_ERROR=400,SERVER_ERROR=500,NON_STANDARD=600};
if(errorCode >= SERVER_ERROR && errorCode < NON_STANDARD)
より
if(errorCode >= 500 && errorCode < 600)
重要な部分はこれで、配列に似ています！ しかし慣れているcast整数値。
短い例：
enum Suit {Diamonds, Hearts, Clubs, Spades};
//does something with values in the enum past "Hearts" in this case
for(int i=0;i<4;i++){
//Could also use i or Hearts, because the enum will turns these both back into an int
if( (Suit)(i) > 1 )
{
//Whatever we'd like to do with (Suit)(i)
}
}
多くの場合、列挙型はchar *配列または文字列配列でも使用されるため、関連する値を含むメッセージを出力できます。通常、それらは次のように列挙型に同じ値のセットを持つ単なる配列です。
char* Suits[4] = {"Diamonds", "Hearts", "Clubs", "Spades"};
//Getting a little redundant
cout << Suits[Clubs] << endl;
//We might want to add this to the above
//cout << Suits[(Suit)(i)] << endl;
そしてもちろん、上記の回答のような列挙型の反復を処理するジェネリッククラスを作成するとさらに便利です。