是否可以将枚举类转换为基础类型

我认为您可以使用std：：underlying_type来了解底层类型，然后使用cast：

#include <type_traits> //for std::underlying_type
typedef std::underlying_type<my_fields>::type utype;
utype a = static_cast<utype>(my_fields::field);

假设底层类型，或者您不必像enum class my_fields : int { .... }左右那样在enum class的定义中提及它。

您甚至可以编写一个通用转换函数，该函数应该能够将任何enum class转换为其底层整型：

template<typename E>
constexpr auto to_integral(E e) -> typename std::underlying_type<E>::type 
{
   return static_cast<typename std::underlying_type<E>::type>(e);
}

然后使用它：

auto value = to_integral(my_fields::field);
auto redValue = to_integral(Color::Red);//where Color is an enum class!

并且由于该函数被声明为 constexpr ，您可以在需要常量表达式的地方使用它：

int a[to_integral(my_fields::field)]; //declaring an array
std::array<int, to_integral(my_fields::field)> b; //better!

您不能隐式转换它，但可以显式强制转换：

enum class my_fields : unsigned { field = 1 };
// ...
unsigned x = my_fields::field; // ERROR!
unsigned x = static_cast<unsigned>(my_fields::field); // OK

还要注意这样一个事实，即分号应该在枚举定义中的闭大括号之后，而不是之前。

使用 C++23，您最终会为此获得一个库函数：

标准：：to_underlying

它已经在 GCC 11、Clang 13 和 MSVC 19.30（又名 2022 17.0）的标准库中实现。

在你能够使用C++23之前，我建议你（重新）命名任何要to_underlying的自定义实现，并将其放在一个#if !defined(__cpp_lib_to_underlying) #endif块之间，这是关联的功能测试宏。这样，当 C++23 可供您使用时，您可以简单地在将来的某个时候放弃代码。

正如其他人指出的那样，没有隐式强制转换，但您可以使用显式static_cast。我在代码中使用以下帮助程序函数来与枚举类型及其基础类进行转换。

    template<typename EnumType>
    constexpr inline decltype(auto) getIntegralEnumValue(EnumType enumValue)
    {
        static_assert(std::is_enum<EnumType>::value,"Enum type required");
        using EnumValueType = std::underlying_type_t<EnumType>;
        return static_cast<EnumValueType>(enumValue);
    }
    template<typename EnumType,typename IntegralType>
    constexpr inline EnumType toEnum(IntegralType value)
    {
        static_assert(std::is_enum<EnumType>::value,"Enum type required");
        static_assert(std::is_integral<IntegralType>::value, "Integer required");
        return static_cast<EnumType>(value);
    }
    template<typename EnumType,typename UnaryFunction>
    constexpr inline void setIntegralEnumValue(EnumType& enumValue, UnaryFunction integralWritingFunction)
    {
        // Since using reinterpret_cast on reference to underlying enum type is UB must declare underlying type value and write to it and then cast it to enum type
        // See discussion on https://stackoverflow.com/questions/19476818/is-it-safe-to-reinterpret-cast-an-enum-class-variable-to-a-reference-of-the-unde
        static_assert(std::is_enum<EnumType>::value,"Enum type required");
        auto enumIntegralValue = getIntegralEnumValue(enumValue);
        integralWritingFunction(enumIntegralValue);
        enumValue = toEnum<EnumType>(enumIntegralValue);
    }

使用代码

enum class MyEnum {
   first = 1,
   second
};
MyEnum myEnum = MyEnum::first;
std::cout << getIntegralEnumValue(myEnum); // prints 1
MyEnum convertedEnum = toEnum(1);
setIntegralEnumValue(convertedEnum,[](auto& integralValue) { ++integralValue; });
std::cout << getIntegralEnumValue(convertedEnum); // prints 2

我发现在必须正确序列化枚举值时underlying_cast以下函数很有用。

namespace util
{
namespace detail
{
    template <typename E>
    using UnderlyingType = typename std::underlying_type<E>::type;
    template <typename E>
    using EnumTypesOnly = typename std::enable_if<std::is_enum<E>::value, E>::type;
}   // namespace util.detail

template <typename E, typename = detail::EnumTypesOnly<E>>
constexpr detail::UnderlyingType<E> underlying_cast(E e) {
    return static_cast<detail::UnderlyingType<E>>(e);
}
}   // namespace util
enum SomeEnum : uint16_t { A, B };
void write(SomeEnum /*e*/) {
    std::cout << "SomeEnum!n";
}
void write(uint16_t /*v*/) {
    std::cout << "uint16_t!n";
}
int main(int argc, char* argv[]) {
    SomeEnum e = B;
    write(util::underlying_cast(e));
    return 0;
}