#include <iostream>
struct a {
enum LOCAL_A { A1, A2 };
};
enum class b { B1, B2 };
int foo(int input) { return input; }
int main(void) {
std::cout << foo(a::A1) << std::endl;
std::cout << foo(static_cast<int>(b::B2)) << std::endl;
}
a::LOCAL_A 是强类型枚举试图实现的目标，但有一个小差别：普通枚举可以转换为整数类型，而强类型枚举不能在不使用强制转换的情况下进行转换。
那么，有没有办法将强类型枚举值转换为整数类型而不需要强制转换？如果有，怎么做呢？
正如其他人所说，你无法进行隐式转换，这是有意为之的。
如果你愿意，你可以避免在转换中指定底层类型。
template <typename E>
constexpr typename std::underlying_type<E>::type to_underlying(E e) noexcept {
return static_cast<typename std::underlying_type<E>::type>(e);
}
std::cout << foo(to_underlying(b::B2)) << std::endl;
强类型枚举旨在解决多个问题，而不仅仅是您在问题中提到的作用域问题：
因此，无法将强类型枚举隐式转换为整数，甚至无法将其底层类型隐式转换为整数 - 这就是这个想法。因此，您必须使用 static_cast 来使转换明确。
如果您唯一的问题是作用域，并且您真的希望将其隐式提升为整数，则最好使用未强制类型化的枚举，其作用域为声明它的结构。
static_cast。这样你的代码会更加清晰易懂。 - Nicol Bolasstatic_cast只会使代码看起来难看且不易读。如果我已经明确指定了底层类型，为什么还要这样做？旧式枚举类型的解决方案优美而美观，问题在于它们的作用域。新的枚举类型增加了作用域，但却减少了二进制掩码和直接值比较的能力。对我来说这很奇怪。大量此类问题的存在清楚地表明这不仅仅是我的问题。 - avtomaton一个C++14版本的答案，由R. Martinho Fernandes提供：
#include <type_traits>
template <typename E>
constexpr auto to_underlying(E e) noexcept
{
return static_cast<std::underlying_type_t<E>>(e);
}
noexcept 关键字，因为它永远不会抛出异常。
更新
这也出现在 Effective Modern C++ by Scott Meyers 中。请参见第10条（在我拥有的书的最后几页中详细说明）。
C++23 版本可以使用 std::to_underlying 函数：
#include <utility>
std::cout << std::to_underlying(b::B2) << std::endl;
...或者如果底层类型可以是1字节类型：
std::cout << +(std::to_underlying(b::B2)) << std::endl;
其他回答已经解释了没有隐式转换的原因（出于设计考虑）。
我个人使用一元运算符+将枚举类转换为其基础类型：
template <typename T>
constexpr auto operator+(T e) noexcept
-> std::enable_if_t<std::is_enum<T>::value, std::underlying_type_t<T>>
{
return static_cast<std::underlying_type_t<T>>(e);
}
这样可以大大减少"打字开销":
std::cout << foo(+b::B2) << std::endl;
#define UNSIGNED_ENUM_CLASS(name, ...) enum class name : unsigned { __VA_ARGS__ };\
inline constexpr unsigned operator+ (name const val) { return static_cast<unsigned>(val); }
简短回答是你无法这样做，正如之前的帖子所指出的那样。但对于我的情况，我只是不想混淆命名空间，但仍然需要隐式转换，所以我只是这样做了：
#include <iostream>
using namespace std;
namespace Foo {
enum Foo { bar, baz };
}
int main() {
cout << Foo::bar << endl; // 0
cout << Foo::baz << endl; // 1
return 0;
}
通过命名空间对枚举类型进行排序，在不需要将任何枚举值静态转换为底层类型的情况下，增加了一层类型安全性。
Foo::Foo。成员可以作为Foo::bar和Foo::baz进行访问，并且可以隐式转换（因此没有太多类型安全性）。如果要开始一个新项目，最好几乎总是使用枚举类。 - solstice333static_cast<> 可能会降低类型安全性，因为它非常强大，可能会将某些不应该转换的内容进行转换。 - jrh不，没有自然的方式。
事实上，C++11中拥有强类型enum class的一个动机是防止它们被隐式转换为int。
#include <cstdlib>
#include <cstdio>
#include <cstdint>
#include <type_traits>
namespace utils
{
namespace details
{
template< typename E >
using enable_enum_t = typename std::enable_if< std::is_enum<E>::value,
typename std::underlying_type<E>::type
>::type;
} // namespace details
template< typename E >
constexpr inline details::enable_enum_t<E> underlying_value( E e )noexcept
{
return static_cast< typename std::underlying_type<E>::type >( e );
}
template< typename E , typename T>
constexpr inline typename std::enable_if< std::is_enum<E>::value &&
std::is_integral<T>::value, E
>::type
to_enum( T value ) noexcept
{
return static_cast<E>( value );
}
} // namespace utils
int main()
{
enum class E{ a = 1, b = 3, c = 5 };
constexpr auto a = utils::underlying_value(E::a);
constexpr E b = utils::to_enum<E>(5);
constexpr auto bv = utils::underlying_value(b);
printf("a = %d, b = %d", a,bv);
return 0;
}
希望这能对你或其他人有所帮助
enum class EnumClass : int //set size for enum
{
Zero, One, Two, Three, Four
};
union Union //This will allow us to convert
{
EnumClass ec;
int i;
};
int main()
{
using namespace std;
//convert from strongly typed enum to int
Union un2;
un2.ec = EnumClass::Three;
cout << "un2.i = " << un2.i << endl;
//convert from int to strongly typed enum
Union un;
un.i = 0;
if(un.ec == EnumClass::Zero) cout << "True" << endl;
return 0;
}
un.i 之后，它就是“激活成员”，你只能读取联合体的激活成员。 - Jonathan Wakelystatic_cast 更易读，这让我感到绝望。请注意，翻译时不要改变原意。 - underscore_denum class中是不可能的，但是你可以使用class来模拟enum class：
在这种情况下，
enum class b
{
B1,
B2
};
将相当于：
class b {
private:
int underlying;
public:
static constexpr int B1 = 0;
static constexpr int B2 = 1;
b(int v) : underlying(v) {}
operator int() {
return underlying;
}
};
这基本上相当于原始的enum class。你可以在返回类型为b的函数中直接返回b::B1。你可以使用switch case，等等。
根据此示例的精神，您可以使用模板（可能与其他内容一起）来泛化和模拟由enum class语法定义的任何可能的对象。
enum class无法使用。struct TextureUploadFormat {
enum Type : uint32 {
r,
rg,
rgb,
rgba,
__count
};
};
// must use ::Type, which is the extra typing with this method; beats all the static_cast<>()
uint32 getFormatStride(TextureUploadFormat::Type format){
const uint32 formatStride[TextureUploadFormat::__count] = {
1,
2,
3,
4
};
return formatStride[format]; // decays without complaint
}
struct而不是namespace来封装枚举的理由？ - jrhTextureUploadFormat是一个命名空间，您可以多次使用该命名空间并意外合并两个枚举的命名空间。 - jrhDescriptiveEnumTypeName::Value），但另一方面，你如何给_实际的_ enum 类型命名呢？无论你怎么称呼它，实际类型名称都会出现在声明中，比如DescriptiveEnumTypeName::RealEnumTypeName，这...令人沮丧。 - Sz.DescriptiveEnumTypeName::Value），但另一方面，你要如何命名_实际的_ enum 类型呢？无论你如何命名，实际类型名称都会出现在声明中，比如DescriptiveEnumTypeName::RealEnumTypeName，这实在是令人沮丧。 - undefinedstruct投降，一个小小的回报是，现在你可以自然地和逐渐地扩展/加固它（虽然有些乏味，也令人沮丧，但至少可行），以实现枚举类的某些好处，如果你以后愿意的话。 - Sz.
std::to_underlying()函数模板用于实现上述功能。 - adentinger