web-dev-qa-db-ja.com

C ++のどのタイプセーフ列挙を使用していますか？

C++の組み込み列挙型はタイプセーフではないことは一般的な知識です。タイプセーフな列挙型を実装するクラスがそこで使用されているのではないかと思っていました...私自身は次の「自転車」を使用していますが、多少冗長で制限があります。

typesafeenum.h：

struct TypesafeEnum
{
// Construction:
public:
    TypesafeEnum(): id (next_id++), name("") {}
    TypesafeEnum(const std::string& n): id(next_id++), name(n) {}

// Operations:
public:
    bool operator == (const TypesafeEnum& right) const;
    bool operator != (const TypesafeEnum& right) const;
    bool operator < (const TypesafeEnum& right) const;

    std::string to_string() const { return name; }

// Implementation:
private:
    static int next_id;
    int id;
    std::string name;
};

typesafeenum.cpp：

int TypesafeEnum::next_id = 1;

bool TypesafeEnum::operator== (const TypesafeEnum& right) const 
{ return id == right.id; }

bool TypesafeEnum::operator!= (const TypesafeEnum& right) const 
{ return !operator== (right); }

bool TypesafeEnum::operator< (const TypesafeEnum& right) const  
{ return id < right.id; }

使用法：

class Dialog 
{
 ...
    struct Result: public TypesafeEnum
    {
        static const Result CANCEL("Cancel");
        static const Result OK("Ok");
    };


    Result doModal();
 ...
};

const Dialog::Result Dialog::Result::OK;
const Dialog::Result Dialog::Result::CANCEL;

追加：要件についてもっと具体的だったと思います。それらを要約してみます。

優先度1：enum変数を無効な値に設定することは、例外なく不可能（コンパイル時エラー）でなければなりません。

優先順位2：enum値とintの間の変換は、単一の明示的な関数/メソッド呼び出しで可能でなければなりません。

優先度3：できる限りコンパクトでエレガントで便利な宣言と使用法

優先度4：enum値と文字列の相互変換。

優先度5：（持つ必要がある）列挙値を反復処理する可能性。

design-patternsenumsenumerationtype-safetyc++03
44
Alex Jenter

私は現在 Boost Vault （ファイル名enum_rev4.6.Zip）からのBoost.Enumプロポーザルで遊んでいます。 Boostに含めるために公式に提出されたことはありませんが、そのまま使用できます。 （ドキュメントは不足していますが、明確なソースコードと適切なテストによって構成されています。）

Boost.Enumを使用すると、次のような列挙型を宣言できます。

BOOST_ENUM_VALUES(Level, const char*,
    (Abort)("unrecoverable problem")
    (Error)("recoverable problem")
    (Alert)("unexpected behavior")
    (Info) ("expected behavior")
    (Trace)("normal flow of execution")
    (Debug)("detailed object state listings")
)

そして、それを自動的にこれに拡張します：

class Level : public boost::detail::enum_base<Level, string>
{
public:
    enum domain
    {
        Abort,
        Error,
        Alert,
        Info,
        Trace,
        Debug,
    };

    BOOST_STATIC_CONSTANT(index_type, size = 6);

    Level() {}
    Level(domain index) : boost::detail::enum_base<Level, string>(index) {}

    typedef boost::optional<Level> optional;
    static optional get_by_name(const char* str)
    {
        if(strcmp(str, "Abort") == 0) return optional(Abort);
        if(strcmp(str, "Error") == 0) return optional(Error);
        if(strcmp(str, "Alert") == 0) return optional(Alert);
        if(strcmp(str, "Info") == 0) return optional(Info);
        if(strcmp(str, "Trace") == 0) return optional(Trace);
        if(strcmp(str, "Debug") == 0) return optional(Debug);
        return optional();
    }

private:
    friend class boost::detail::enum_base<Level, string>;
    static const char* names(domain index)
    {
        switch(index)
        {
        case Abort: return "Abort";
        case Error: return "Error";
        case Alert: return "Alert";
        case Info: return "Info";
        case Trace: return "Trace";
        case Debug: return "Debug";
        default: return NULL;
        }
    }

    typedef boost::optional<value_type> optional_value;
    static optional_value values(domain index)
    {
        switch(index)
        {
        case Abort: return optional_value("unrecoverable problem");
        case Error: return optional_value("recoverable problem");
        case Alert: return optional_value("unexpected behavior");
        case Info: return optional_value("expected behavior");
        case Trace: return optional_value("normal flow of execution");
        case Debug: return optional_value("detailed object state listings");
        default: return optional_value();
        }
    }
};

リストした5つの優先順位すべてを満たします。

42
Josh Kelley

良い妥協方法はこれです：

struct Flintstones {
   enum E {
      Fred,
      Barney,
      Wilma
   };
};

Flintstones::E fred = Flintstones::Fred;
Flintstones::E barney = Flintstones::Barney;

バージョンと同じ意味でタイプセーフではありませんが、使用方法は標準の列挙型よりも優れており、必要に応じて整数変換を利用できます。

18
Charlie

私は C++ 0x typesafe enums を使用しています。 to/from文字列機能を提供するヘルパーテンプレート/マクロを使用しています。

enum class Result { Ok, Cancel};
12
Roddy

私はしません。オーバーヘッドが多すぎてほとんどメリットがありません。また、列挙を異なるデータ型にキャストしてシリアル化できることは、非常に便利なツールです。 C++が十分に優れた実装を既に提供している場合、「タイプセーフ」な列挙がオーバーヘッドと複雑さの価値があるインスタンスを見たことはありません。

6
user19302

私は typesafe enum idiom の適応バージョンを個人的に使用しています。これは、編集で述べた5つの「要件」のすべてを提供しているわけではありませんが、とにかく、それらのいくつかには強く同意しません。たとえば、Prio＃4（値から文字列への変換）がタイプセーフとどのように関係しているかはわかりません。とにかく、ほとんどの場合、個々の値の文字列表現は、型の定義とは別にする必要があります（単純な理由でi18nを考えてください）。 Prio＃5（イテレーション、オプション）は、列挙型で自然に発生することを望んでいる最も良いものの1つなので、悲しい思いをしましたリクエストでは「オプション」として表示されますが、begin/end関数やenum_iteratorなどの 個別の反復システム を使用するほうが適切なようです。 STLおよびC++ 11 foreachとシームレスに連携します。

OTOHこの単純なイディオムは、ほとんどの場合、enumsをより多くの型情報でラップするだけなので、Prio＃3 Prio＃1をうまく提供します。言うまでもなく、これは非常に単純なソリューションであり、ほとんどの場合、外部の依存関係ヘッダーを必要としないため、持ち運びが非常に簡単です。また、列挙型スコープのa-la-C++ 11を作成できるという利点もあります。

// This doesn't compile, and if it did it wouldn't work anyway
enum colors { salmon, .... };
enum fishes { salmon, .... };

// This, however, works seamlessly.
struct colors_def { enum type { salmon, .... }; };
struct fishes_def { enum type { salmon, .... }; };

typedef typesafe_enum<colors_def> colors;
typedef typesafe_enum<fishes_def> fishes;

ソリューションが提供する唯一の「穴」は、異なるタイプのenums（またはenumとint）が直接比較されるのを妨げないという事実に対処しないことです。値を直接使用する場合、暗黙的にintに変換するためです。

if (colors::salmon == fishes::salmon) { .../* Ooops! */... }

しかし、これまでのところ、このような問題は、コンパイラとの比較を改善するだけで解決できることがわかりました。たとえば、2つの異なるenum型を比較す​​る演算子を明示的に指定し、強制的に失敗させます。

// I'm using backports of C++11 utilities like static_assert and enable_if
template <typename Enum1, typename Enum2>
typename enable_if< (is_enum<Enum1>::value && is_enum<Enum2>::value) && (false == is_same<Enum1,Enum2>::value) , bool >
::type operator== (Enum1, Enum2) {
    static_assert (false, "Comparing enumerations of different types!");
}

これまでのところコードを壊すようには見えませんし、他に何もせずに特定の問題に明示的に対処することはできますが、そのようなことが「 "do（他の場所で宣言された変換演算子にすでに参加しているenumsに干渉するのではないかと思います。これについてのコメントを喜んで受け取ります）。

これを上記のタイプセーフなイディオムと組み合わせると、C++ 11に比較的近いものになりますenum class人間味（可読性と保守性）の点で、あまりあいまいなことをする必要はありません。そして、私がそれをするのが楽しかったことを認めなければなりません、私が実際にenumsを扱っているなら、コンパイラにaskすることを考えたことはありませんでしたか、ない...

2
Luis Machuca

私の考えでは、あなたは問題を作り出し、それに解決策をはめ込むということです。値の列挙のために複雑なフレームワークを実行する必要がないと思います。 専用を使用して値を特定のセットのメンバーのみにする場合、一意のセットのデータ型のバリアントをハックアップできます。

2
Paul Nathan

私はこれに答えを出しました here 、別のトピックについて。これは別のスタイルのアプローチであり、元の列挙型定義を変更することなく同じ機能のほとんどを許可します（その結果、列挙型を定義しない場合でも使用できます）。また、実行時の範囲チェックも可能です。

私のアプローチの欠点は、列挙型とヘルパークラス間の結合をプログラムで強制しないため、それらを並行して更新する必要があることです。それは私のために働くが、YMMV。

1
Nick

Java enumは良いモデルになると思います。基本的に、Javaフォームは次のようになります：

public enum Result {
    OK("OK"), CANCEL("Cancel");

    private final String name;

    Result(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Javaアプローチの興味深い点は、OKおよびCANCELがResultの不変のシングルトンインスタンスであるということです（表示されるメソッドを使用）） 。Resultのインスタンスをこれ以上作成することはできません。これらはシングルトンなので、ポインター/参照で比較できます---非常に便利です。:-)

ETA：Javaでは、ビットマスクを手動で行う代わりに、EnumSetを使用してビットセットを指定します（これはSetインターフェイスを実装し、セットのように機能しますが、ビットマスクを使用して実装されます） ）。手書きのビットマスク操作よりもはるかに読みやすいです！

1
Chris Jester-Young

boost::variantを使用してください！

上記のアイデアの多くを試してみて不足していることを見つけた後、私はこの単純なアプローチに思い当たりました。

#include <iostream>
#include <boost/variant.hpp>

struct A_t {};
static const A_t A = A_t();
template <typename T>
bool isA(const T & x) { if(boost::get<A_t>(&x)) return true; return false; }

struct B_t {};
static const B_t B = B_t();
template <typename T>
bool isB(const T & x) { if(boost::get<B_t>(&x)) return true; return false; }

struct C_t {};
static const C_t C = C_t();
template <typename T>
bool isC(const T & x) { if(boost::get<C_t>(&x)) return true; return false; }

typedef boost::variant<A_t, B_t> AB;
typedef boost::variant<B_t, C_t> BC;

void ab(const AB & e)
{
  if(isA(e))
    std::cerr << "A!" << std::endl;
  if(isB(e))
    std::cerr << "B!" << std::endl;
  // ERROR:
  // if(isC(e))
  //   std::cerr << "C!" << std::endl;

  // ERROR:
  // if(e == 0)
  //   std::cerr << "B!" << std::endl;
}

void bc(const BC & e)
{
  // ERROR:
  // if(isA(e))
  //   std::cerr << "A!" << std::endl;

  if(isB(e))
    std::cerr << "B!" << std::endl;
  if(isC(e))
    std::cerr << "C!" << std::endl;
}

int main() {
  AB a;
  a = A;
  AB b;
  b = B;
  ab(a);
  ab(b);
  ab(A);
  ab(B);
  // ab(C); // ERROR
  // bc(A); // ERROR
  bc(B);
  bc(C);
}

おそらく、ボイラープレートを生成するためのマクロを考え出すことができます。 （もしそうなら私に知らせてください。）

他のアプローチとは異なり、これは実際にはタイプセーフであり、古いC++で動作します。たとえば、boost::variant<int, A_t, B_t, boost::none>のようなクールなタイプを作成して、A、B、整数、またはほとんどHaskell98レベルのタイプセーフである何もない値を表すこともできます。

注意すべき欠点：

  • 少なくとも古いブーストの場合-私はシステム1.33のブーストを使用しています-バリアントでは20アイテムに制限されています。ただし、回避策があります
  • コンパイル時間に影響します
  • 非常識なエラーメッセージ-それはあなたにとってC++です

更新

ここでは、あなたの便宜のために、あなたのタイプセーフな列挙型「ライブラリ」があります。このヘッダーを貼り付けます：

#ifndef _TYPESAFE_ENUMS_H
#define _TYPESAFE_ENUMS_H
#include <string>
#include <boost/variant.hpp>

#define ITEM(NAME, VAL) \
struct NAME##_t { \
  std::string toStr() const { return std::string( #NAME ); } \
  int toInt() const { return VAL; } \
}; \
static const NAME##_t NAME = NAME##_t(); \
template <typename T> \
bool is##NAME(const T & x) { if(boost::get<NAME##_t>(&x)) return true; return false; } \


class toStr_visitor: public boost::static_visitor<std::string> {
public:
  template<typename T>
  std::string operator()(const T & a) const {
    return a.toStr();
  }
};

template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
std::string toStr(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
  return boost::apply_visitor(toStr_visitor(), a);
}

class toInt_visitor: public boost::static_visitor<int> {
public:
  template<typename T>
  int operator()(const T & a) const {
    return a.toInt();
  }
};

template<BOOST_VARIANT_ENUM_PARAMS(typename T)>
inline static
int toInt(const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & a) {
  return boost::apply_visitor(toInt_visitor(), a);
}

#define ENUM(...) \
typedef boost::variant<__VA_ARGS__>
#endif

そしてそれを次のように使用します：

ITEM(A, 0);
ITEM(B, 1);
ITEM(C, 2);

ENUM(A_t, B_t) AB;
ENUM(B_t, C_t) BC;

AマクロでENUMの代わりにA_tと言う必要があることに注意してください。これにより、魔法の一部が破壊されます。しかたがない。また、文字列と整数への単純な変換のOP要件を満たすtoStr関数とtoInt関数があることに注意してください。私が理解できない要件は、アイテムを反復する方法です。あなたがそのようなものを書く方法を知っているなら、私に知らせてください。

0
Michael Fox

https://bitbucket.org/chopsii/typesafe-enums で自分のタイプセーフ列挙ライブラリを現在書いています。

私はこれまでで最も経験豊富なC++開発者ではありませんが、BOOSTボールトの列挙型の欠点のため、これを書いています。

自由にチェックして、自分で使用してください。ただし、（おそらく軽微な）使いやすさの問題があり、おそらくクロスプラットフォームではありません。

よろしければ投稿してください。これは私の最初のオープンソース事業です。

0
Lynden Shields