在 C++ 中将 int 转换为 enum 的通用方法

Question

在C++中是否有一种通用的方法将int转换为enum？

如果int落在enum的范围内，它应该返回一个enum值，否则抛出异常。有没有办法通用地写它？应该支持多个枚举类型。

背景：我有一个外部枚举类型，并且无法控制源代码。我想将此值存储在数据库中并检索它。

Answer 1

显而易见的事情是注释您的枚举：

// 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 分别是
的最小值和最大值
可以存储 emin 的最小位域
和 emax。可以定义一个
具有不具有值的枚举
由其任何枚举​​器定义。

因此，如果您不是 e 的作者，您可能无法保证 e 的有效值实际出现在其定义中。

Answer 2

丑陋的。

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);

但这比上面更难看，更容易出错，并且不会按照您的意愿抛出。

Answer 3

如果正如您所描述的，这些值位于数据库中，为什么不编写一个代码生成器来读取此表并使用枚举和 to_enum(int) 函数创建 .h 和 .cpp 文件？

优点：

• 易于添加 to_string(my_enum) 函数。
• 几乎不需要维护
• 数据库和代码同步

Answer 4

不，C++ 中没有自省，也没有任何内置的“域检查”设施。

Answer 5

您对此有何看法？

#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"
    }
}

然后，您可以使用我在此处发布的代码来切换值。

Answer 6

您不应该希望存在您所描述的内容，我担心您的代码设计存在问题。

另外，您假设枚举在一个范围内，但情况并非总是如此：

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

这不在一个范围内：即使可能，您是否应该检查从 0 到 2^n 的每个整数以查看它们是否与某些匹配枚举的值？

Answer 7

如果您准备将枚举值列出为模板参数，则可以在 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);
}

Answer 8

C++0x 替代“丑陋”版本，允许多个枚举。使用初始化列表而不是开关，在我看来更干净一些。不幸的是，这并不能解决对枚举值进行硬编码的需要。

#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 );
    }
}