web-dev-qa-db-ja.com

列挙値が有効かどうかを確認する方法は？

バイナリファイルからenum値を読み取っていますが、その値が実際にenum値の一部であるかどうかを確認したいと思います。どうすればいいですか？

#include <iostream>

enum Abc
{
    A = 4,
    B = 8,
    C = 12
};

int main()
{
    int v1 = 4;
    Abc v2 = static_cast< Abc >( v1 );

    switch ( v2 )
    {
        case A:
            std::cout<<"A"<<std::endl;
            break;
        case B:
            std::cout<<"B"<<std::endl;
            break;
        case C:
            std::cout<<"C"<<std::endl;
            break;
        default :
            std::cout<<"no match found"<<std::endl;
    }
}

switch演算子を使用する必要がありますか、それとももっと良い方法がありますか？

[〜＃〜] edit [〜＃〜]

列挙値が設定されていますが、残念ながら変更できません。さらに悪いことに、それらは連続ではありません（値は0、75、76、80、85、90、95、100などになります）

c++enums
44
BЈовић

enum値は、以下の標準ルールで定義されている範囲[A、B]に含まれる場合、C++で有効です。したがって、enum X { A = 1, B = 3 }の場合、2の値は有効な列挙値と見なされます。

標準の7.2/6を考慮してください：

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

C++には遡及はありません。取る方法の1つは、配列内の列挙値を追加でリストし、変換を行い、失敗した場合に例外をスローするラッパーを作成することです。

詳細については、intをenumにキャストする方法について 類似質問 を参照してください。

23
Leonid

たぶん、このような列挙型を使用してください：

enum MyEnum
{
A,
B,
C
};

そして確認する

if (v2 >= A && v2 <= C)

Enum定数の値を指定しない場合、値はゼロから始まり、リストを下に移動するたびに1ずつ増加します。たとえば、enum MyEnumType { ALPHA, BETA, GAMMA }; ALPHAの値は0、BETAの値は1、GAMMAの値は2です。

9
Andrew

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

以下の例に役立つ可能性のある追加は、切り捨ての問題を回避するために、IntTypeに対するEnumTypeの基になる型の周りのいくつかの静的アサーションです。演習として残しました。

#include <stdio.h>

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<IntType>(V) || super::is_value(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);
}
9
janm

私がこれを「簡単」にするために見つけた唯一の方法は、列挙型のソートされた配列を作成（マクロ）し、それをチェックすることでした。

switchには、指定された値を持つ複数の列挙子があるため、enumトリックはenumsで失敗します。

それは本当に迷惑な問題です。

7
Matthieu M.

Managed Extensions for C++は、次の構文をサポートしています。

enum Abc
{
    A = 4,
    B = 8,
    C = 12
};

Enum::IsDefined(Abc::typeid, 8);

参照：MSDN " C++プログラミング用の管理された拡張機能 "

4
Brett

Kinda necro、しかし... intのRANGEチェックを最初/最後の列挙値に（厳密なチェックを行うためのjanmのアイデアと組み合わせることができます）、C++ 11：

ヘッダ：

namespace chkenum
{
    template <class T, T begin, T end>
    struct RangeCheck
    {
    private:
        typedef typename std::underlying_type<T>::type val_t;
    public:
        static
        typename std::enable_if<std::is_enum<T>::value, bool>::type
        inrange(val_t value)
        {
            return value >= static_cast<val_t>(begin) && value <= static_cast<val_t>(end);
        }
    };

    template<class T>
    struct EnumCheck;
}

#define DECLARE_ENUM_CHECK(T,B,E) namespace chkenum {template<> struct EnumCheck<T> : public RangeCheck<T, B, E> {};}

template<class T>
inline
typename std::enable_if<std::is_enum<T>::value, bool>::type
testEnumRange(int val)
{
    return chkenum::EnumCheck<T>::inrange(val);
}

列挙型宣言：

enum MinMaxType
{
     Max = 0x800, Min, Equal
};
DECLARE_ENUM_CHECK(MinMaxType, MinMaxType::Max, MinMaxType::Equal);

使用法：

bool r = testEnumRange<MinMaxType>(i);

上記の主な違いは、テスト関数が列挙型自体のみに依存することを提案しました。

3
Alex Zaharov

言語について言えば、それ以上の方法はありません。列挙値はコンパイル時にのみ存在し、プログラムで列挙する方法はありません。ただし、よく考えられたインフラストラクチャを使用すると、すべての値を何度もリストすることを回避できる場合があります。 Cで列挙型の変数を文字列として使用する簡単な方法 を参照してください

サンプルは、そこで提供される「enumFactory.h」を使用して書き換えることができます。

#include "enumFactory.h"

#define ABC_ENUM(XX) \
    XX(A,=4) \
    XX(B,=8) \
    XX(C,=12) \

DECLARE_ENUM(Abc,ABC_ENUM)

int main()
{
    int v1 = 4;
    Abc v2 = static_cast< Abc >( v1 );

    #define CHECK_ENUM_CASE(name,assign) case name: std::cout<< #name <<std::endl; break;
    switch ( v2 )
    {
        ABC_ENUM(CHECK_ENUM_CASE)
        default :
            std::cout<<"no match found"<<std::endl;
    }
    #undef CHECK_ENUM_CASE
}

または（そのヘッダーに既に存在するいくつかの機能を使用して）：

#include "enumFactory.h"

#define ABC_ENUM(XX) \
    XX(A,=4) \
    XX(B,=8) \
    XX(C,=12) \

DECLARE_ENUM(Abc,ABC_ENUM)
DEFINE_ENUM(Abc,ABC_ENUM)

int main()
{
    int v1 = 4;
    Abc v2 = static_cast< Abc >( v1 );
    const char *name = GetString(v2);
    if (name[0]==0) name = "no match found";
    std::cout << name << std::endl;
}
2
Suma

さらに別の方法：

#include <algorithm>
#include <iterator>
#include <iostream>

template<typename>
struct enum_traits { static constexpr void* values = nullptr; };

namespace detail
{

template<typename T>
constexpr bool is_value_of(int, void*) { return false; }

template<typename T, typename U>
constexpr bool is_value_of(int v, U)
{
    using std::begin; using std::end;

    return std::find_if(begin(enum_traits<T>::values), end(enum_traits<T>::values),
        [=](auto value){ return value == static_cast<T>(v); }
    ) != end(enum_traits<T>::values);
}

}

template<typename T>
constexpr bool is_value_of(int v)
{ return detail::is_value_of<T>(v, decltype(enum_traits<T>::values) { }); }

////////////////////
enum Abc { A = 4, B = 8, C = 12 };

template<>
struct enum_traits<Abc> { static constexpr auto values = { A, B, C }; };
decltype(enum_traits<Abc>::values) enum_traits<Abc>::values;

enum class Def { D = 1, E = 3, F = 5 };

int main()
{
    std::cout << "Abc:";
    for(int i = 0; i < 10; ++i)
        if(is_value_of<Abc>(i)) std::cout << " " << i;
    std::cout << std::endl;

    std::cout << "Def:";
    for(int i = 0; i < 10; ++i)
        if(is_value_of<Def>(i)) std::cout << " " << i;
    std::cout << std::endl;

    return 0;
}

私見のこのアプローチの「 "い」部分は以下を定義しなければなりません：

decltype(enum_traits<Abc>::values) enum_traits<Abc>::values

マクロに反対していない場合は、マクロ内にラップできます。

#define REGISTER_ENUM_VALUES(name, ...) \
template<> struct enum_traits<name> { static constexpr auto values = { __VA_ARGS__ }; }; \
decltype(enum_traits<name>::values) enum_traits<name>::values;
0
Innocent Bystander