如何检查枚举值是否有效？
我正在读取一个二进制文件的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操作员还是有更好的方法？
编辑
我有枚举值设置，不幸的是我不能修改它们。 更糟糕的是，它们并不是连续的（它们的值是0,75,76,80,85,90,95,100等）
enum值落在由下面的标准规则定义的范围[A，B]中，则在C ++中有效。 所以在enum X { A = 1, B = 3 } ，值2被认为是一个有效的枚举值。
考虑标准的7.2 / 6：
对于其中emin是最小枚举数并且emax是最大的枚举，枚举的值是在bmin到bmax范围内的基础types的值，其中bmin和bmax分别是最小值和最大值可以存储emin和emax的位字段。 有可能定义一个枚举值，它的值不是由任何枚举器定义的。
在C ++中没有回顾。 一种方法是额外列出数组中的枚举值，并编写一个可以进行转换的包装器，并可能在失败时抛出exception。
看到类似的问题关于如何投入整数枚举进一步的细节。
也许使用这样的枚举：
enum MyEnum { A, B, C };
并检查
if (v2 >= A && v2 <= C)
如果您不指定枚举常量的值，则值从零开始，每次向下移动列表中的值。 例如，给定enum MyEnumType { ALPHA, BETA, GAMMA }; ALPHA的值为0，BETA的值为1，GAMMA的值为2。
我发现“简单”的唯一方法是创build（macros）一个sorting的枚举数组，然后用它来检查。
switch技巧因enum而失败，因为enum可能有多个具有给定值的枚举器。
这真是一个烦人的问题。
在C ++ 11中，如果您准备将枚举值列为模板参数，则有更好的方法。 您可以将此视为一件好事，让您在不同的上下文中接受有效枚举值的子集; 在parsing来自外部的代码时通常很有用。
下面的例子中可能有用的补充是围绕EnumType相对于IntType的基本types的一些静态断言，以避免截断问题。 留作练习。
#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); }
C ++托pipe扩展支持以下语法：
enum Abc { A = 4, B = 8, C = 12 }; Enum::IsDefined(Abc::typeid, 8);
参考：MSDN“ 用于C ++编程的托pipe扩展 ”
说到一种语言，没有更好的办法，枚举值只存在编译时间，没有办法枚举它们的编程方式。 但是，通过一个精心devise的基础架构，您仍然可以避免多次列出所有值。 请参阅简单的方法来使用枚举types的variables作为C中的string？
然后可以使用提供的“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; }
有点necro，但是…做int的范围检查到第一个/最后一个枚举值（可以结合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);
以上主要区别仅在于testing函数依赖于枚举types本身。
还有另一种方法来做到这一点：
#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
如果你不反对macros，你可以把它包装在一个macros中：
#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;
