web-dev-qa-db-ja.com

C ++で列挙型にintをキャストする一般的な方法

intをC++のenumにキャストする一般的な方法はありますか？

intがenumの範囲内にある場合、enum値を返す必要があります。それ以外の場合は、exceptionをスローします。それを書く方法はありますか一般的に？複数のenum typeをサポートする必要があります。

背景：外部enumタイプとno controlがあります。この値をデータベースに保存して取得したいと思います。

c++castingenums
79
Leonid

明らかなことは、列挙型に注釈を付けることです。

// generic code
#include <algorithm>

template <typename T>
struct enum_traits {};

template<typename T, size_t N>
T *endof(T (&ra)[N]) {
    return ra + N;
}

template<typename T, typename ValType>
T check(ValType v) {
    typedef enum_traits<T> traits;
    const T *first = traits::enumerators;
    const T *last = endof(traits::enumerators);
    if (traits::sorted) { // probably premature optimization
        if (std::binary_search(first, last, v)) return T(v);
    } else if (std::find(first, last, v) != last) {
        return T(v);
    }
    throw "exception";
}

// "enhanced" definition of enum
enum e {
    x = 1,
    y = 4,
    z = 10,
};

template<>
struct enum_traits<e> {
    static const e enumerators[];
    static const bool sorted = true;
};
// must appear in only one TU,
// so if the above is in a header then it will need the array size
const e enum_traits<e>::enumerators[] = {x, y, z};

// usage
int main() {
    e good = check<e>(1);
    e bad = check<e>(2);
}

eを使用して配列を最新の状態に保つ必要がありますが、これはeの作成者ではない場合は厄介です。 Sjoerdが言うように、それはおそらく、適切なビルドシステムで自動化できます。

いずれにせよ、あなたは7.2/6に立ち向かっています：

Eminが最小の列挙子で、emaxが最大の列挙の場合、列挙の値はbminからbmaxの範囲の基になる型の値です。bminとbmaxはそれぞれ、最小の最小値と最大値ですエミンとemaxを格納できるビットフィールド。列挙子によって定義されていない値を持つ列挙を定義することができます。

したがって、あなたがeの作成者でない場合、eの有効な値が実際にその定義に現れるという保証があるかもしれません。

37
Steve Jessop

醜い。

enum MyEnum { one = 1, two = 2 };

MyEnum to_enum(int n)
{
  switch( n )
  {
    case 1 :  return one;
    case 2 : return two;
  }
  throw something();
}

さて、本当の質問です。なぜこれが必要なのですか？コードは見苦しく、簡単に記述（*？）できず、保守も簡単でもなく、コードに組み込むのも簡単ではありません。それが間違っていることを伝えるコード。なぜ戦うのか？

編集：

または、列挙型がC++の整数型である場合：

enum my_enum_val = static_cast<MyEnum>(my_int_val);

しかし、これは上記よりもく、エラーが発生しやすく、望みどおりにスローされません。

20
John Dibling

説明したように、値がデータベースにある場合、このテーブルを読み取り、enum関数とto_enum(int)関数の両方で.hおよび.cppファイルを作成するコードジェネレーターを作成してみませんか？

利点：

  • to_string(my_enum)関数を簡単に追加できます。
  • メンテナンスがほとんど不要
  • データベースとコードは同期しています
3
Sjoerd

これについてどう思いますか？

#include <iostream>
#include <stdexcept>
#include <set>
#include <string>

using namespace std;

template<typename T>
class Enum
{
public:
    static void insert(int value)
    {
        _set.insert(value);
    }

    static T buildFrom(int value)
    {
        if (_set.find(value) != _set.end()) {
            T retval;
            retval.assign(value);
            return retval;
        }
        throw std::runtime_error("unexpected value");
    }

    operator int() const { return _value; }

private:
    void assign(int value)
    {
        _value = value;
    }

    int _value;
    static std::set<int> _set;
};

template<typename T> std::set<int> Enum<T>::_set;

class Apples: public Enum<Apples> {};

class Oranges: public Enum<Oranges> {};

class Proxy
{
public:
    Proxy(int value): _value(value) {}

    template<typename T>
    operator T()
    {
        T theEnum;
        return theEnum.buildFrom(_value);
    }

    int _value;
};

Proxy convert(int value)
{
    return Proxy(value);
}

int main()
{    
    Apples::insert(4);
    Apples::insert(8);

    Apples a = convert(4); // works
    std::cout << a << std::endl; // prints 4

    try {
        Apples b = convert(9); // throws    
    }
    catch (std::exception const& e) {
        std::cout << e.what() << std::endl; // prints "unexpected value"
    }
    try {
        Oranges b = convert(4); // also throws  
    }
    catch (std::exception const& e) {
        std::cout << e.what() << std::endl; // prints "unexpected value"
    }
}

その後、私が投稿したコード here を使用して値を有効にできます。

2
Simone

いいえ。C++にはイントロスペクションもありませんし、組み込みの「ドメインチェック」機能もありません。

2
luke

列挙値をテンプレートパラメータとしてリストする準備ができている場合は、C++ 11で可変テンプレートを使用してこれを行うことができます。これは良いことと見なすことができ、異なるコンテキストで有効な列挙値のサブセットを受け入れることができます。多くの場合、外部ソースからのコードを解析するときに役立ちます。

おそらくあなたが望むほど一般的ではありませんが、チェックコード自体は一般化されているので、値のセットを指定するだけです。このアプローチは、ギャップ、任意の値などを処理します。

template<typename EnumType, EnumType... Values> class EnumCheck;

template<typename EnumType> class EnumCheck<EnumType>
{
public:
    template<typename IntType>
    static bool constexpr is_value(IntType) { return false; }
};

template<typename EnumType, EnumType V, EnumType... Next>
class EnumCheck<EnumType, V, Next...> : private EnumCheck<EnumType, Next...>
{
    using super = EnumCheck<EnumType, Next...>;

public:
    template<typename IntType>
    static bool constexpr is_value(IntType v)
    {
        return v == static_cast<typename std::underlying_type<EnumType>::type>(V) || super::is_value(v);
    }

    EnumType convert(IntType v)
    {
        if (!is_value(v)) throw std::runtime_error("Enum value out of range");
        return static_cast<EnumType>(v);
};

enum class Test {
    A = 1,
    C = 3,
    E = 5
};

using TestCheck = EnumCheck<Test, Test::A, Test::C, Test::E>;

void check_value(int v)
{
    if (TestCheck::is_value(v))
        printf("%d is OK\n", v);
    else
        printf("%d is not OK\n", v);
}

int main()
{
    for (int i = 0; i < 10; ++i)
        check_value(i);
}
1
janm

あなたが説明するようなものが存在することは望ましくないはずです。コード設計に問題があるのではないかと心配しています。

また、列挙型が範囲内にあると仮定しますが、常にそうであるとは限りません。

enum Flags { one = 1, two = 2, four = 4, eigh = 8, big = 2000000000 };

これは範囲内ではありません：可能であっても、0から2 ^ nまでのすべての整数をチェックして、それらがいくつかの列挙値に一致するかどうかを確認することになっていますか？

1
Simone

「ugい」バージョンに代わるC++ 0xは、複数の列挙型を許可します。スイッチではなくイニシャライザリストを使用し、IMOを少し簡潔にします。残念ながら、これは列挙値をハードコードする必要性を回避できません。

#include <cassert>  // assert

namespace  // unnamed namespace
{
    enum class e1 { value_1 = 1, value_2 = 2 };
    enum class e2 { value_3 = 3, value_4 = 4 };

    template <typename T>
    int valid_enum( const int val, const T& vec )
    {
        for ( const auto item : vec )
            if ( static_cast<int>( item ) == val ) return val;

        throw std::exception( "invalid enum value!" );  // throw something useful here
    }   // valid_enum
}   // ns

int main()
{
    // generate list of valid values
    const auto e1_valid_values = { e1::value_1, e1::value_2 };
    const auto e2_valid_values = { e2::value_3, e2::value_4 };

    auto result1 = static_cast<e1>( valid_enum( 1, e1_valid_values ) );
    assert( result1 == e1::value_1 );

    auto result2 = static_cast<e2>( valid_enum( 3, e2_valid_values ) );
    assert( result2 == e2::value_3 );

    // test throw on invalid value
    try
    {
        auto result3 = static_cast<e1>( valid_enum( 9999999, e1_valid_values ) );
        assert( false );
    }
    catch ( ... )
    {
        assert( true );
    }
}
0
Tom