#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是强类型enum试图实现的目标,但有一个小小的区别:普通enum可以转换为整数类型,而强类型enum如果没有强制转换就不能做到这一点。

那么,有没有一种方法可以将强类型枚举值转换为整数类型而不进行强制转换呢?如果是,怎么做?


当前回答

总结

问题:

是否有一种方法将强类型枚举值转换为整数类型而不强制转换?如果是,怎么做?

答:

不,没有。如果没有显式强制转换,强类型枚举不能转换为整数。但是,弱枚举可以,因为它们将自动隐式强制转换。所以,如果你想自动隐式转换为int型,可以考虑使用c风格的弱enum(详见“进一步”一节)。

从这里(强调添加):https://en.cppreference.com/w/cpp/language/enum ->节下的“范围枚举”:

虽然可以使用static_cast来获得枚举数的数值,但没有从作用域枚举数[AKA: "strong enum"]的值到整型的隐式转换。

进一步:讨论c++中的弱(C风格)和强(c++ enum类)enum类型

在c++中有两种类型的枚举:

“unscoped”,“regular”,“weak”,“弱类型”,或“c风格”枚举 "scoped", "strong", "强类型","枚举类",或" c++风格"枚举。

“作用域”枚举,或“强”枚举,除了“常规”枚举之外,还提供了两个额外的“特性”。

范围的枚举:

不允许从枚举类型隐式转换为整数类型(因此您不能隐式地做您想做的事情!),以及 它们“限定”枚举,因此您必须通过枚举类型名称访问枚举。

1. 枚举类的示例(仅在c++中可用):

// enum class (AKA: "strong" or "scoped" enum)
enum class my_enum
{
    A = 0,
    B,
    C,
};

my_enum e = my_enum::A; // scoped through `my_enum::`
e = my_enum::B;

// NOT ALLOWED!:
//   error: cannot convert ‘my_enum’ to ‘int’ in initialization
// int i = e; 

// But explicit casting works just fine!:
int i1 = static_cast<int>(e); // explicit C++-style cast 
int i2 = (int)e;              // explicit C-style cast 

第一个“特性”实际上可能是您不想要的,在这种情况下,您只需要使用常规的c风格enum即可!好处是:你仍然可以“作用域”或“命名空间”枚举,就像在C语言中几十年来所做的那样,只需在枚举类型名称前加上它的名称,就像这样:

2. 常规枚举的示例(在C和c++中都可用):

// regular enum (AKA: "weak" or "C-style" enum)
enum my_enum
{
    // C-style-scoped through the `MY_ENUM_` prefix
    MY_ENUM_A = 0,
    MY_ENUM_B,
    MY_ENUM_C,
};

my_enum e = MY_ENUM_A; // scoped through `MY_ENUM_`
e = MY_ENUM_B;

// This works fine!
int i = e;

请注意,只要将MY_ENUM_“作用域”添加到每个枚举前面,您仍然可以获得“作用域”的好处!

3.常规枚举和枚举类一起使用:

在这里测试代码:https://onlinegdb.com/BkWGqlqz_。

main.cpp:

#include <iostream>
#include <stdio.h>

// enum class (AKA: "strong" or "scoped" enum [available only in C++, not C])
enum class my_enum
{
    A = 0,
    B,
    C,
};

// regular enum (AKA: "weak" or "C-style" enum [available in BOTH C and C++])
enum my_enum2
{
    MY_ENUM_A = 0,
    MY_ENUM_B,
    MY_ENUM_C,
};


int main()
{
    printf("Hello World\n");

    // 1) scoped enum

    my_enum e = my_enum::A; // scoped through `my_enum::`
    e = my_enum::B;
    
    // IMPLICIT CASTING TO INT IS NOT ALLOWED!
    // int i = e; // "error: cannot convert ‘my_enum’ to ‘int’ in initialization"
    // But this explicit C++-style cast works fine:
    int i1 = static_cast<int>(e); 
    // This explicit C-style cast works fine too, and is easier to read
    int i2 = (int)e;
    
    
    // 2) regular enum 
    
    my_enum2 e2 = MY_ENUM_A; // scoped through `MY_ENUM_`
    e2 = MY_ENUM_B;
    
    // This implicit cast works fine / IS allowed on C-style enums!
    int i3 = e2;
    // These explicit casts are also fine, but explicit casting is NOT 
    // required for regular enums.
    int i4 = static_cast<int>(e2); // explicit C++-style cast 
    int i5 = (int)e2;              // explicit C-style cast 

    return 0;
}

4. 如何遍历枚举:

*****[我的回答]如何迭代的完整示例弱类型的c风格和2。作用域,强类型的c++枚举类枚举:如何遍历枚举? [我的问答]在c++中迭代枚举类的常用方法是什么?

其他回答

由R. Martinho Fernandes提供的答案的c++ 14版本将是:

#include <type_traits>

template <typename E>
constexpr auto to_underlying(E e) noexcept
{
    return static_cast<std::underlying_type_t<E>>(e);
}

与前面的答案一样,这将适用于任何类型的枚举和底层类型。我添加了noexcept关键字,因为它永远不会抛出异常。


更新 这也出现在Scott Meyers的《Effective Modern c++》中。见第10项(在我这本书的最后几页有详细说明)。


c++ 23版本将使用std:: to_底层函数:

#include <utility>

std::cout << std::to_underlying(b::B2) << std::endl;

...或者如果底层类型可以是1字节类型:

std::cout << +(std::to_underlying(b::B2)) << std::endl;

An extension to the answers from R. Martinho Fernandes and Class Skeleton: Their answers show how to use typename std::underlying_type<EnumType>::type or std::underlying_type_t<EnumType> to convert your enumeration value with a static_cast to a value of the underlying type. Compared to a static_cast to some specific integer type, like, static_cast<int> this has the benefit of being maintenance friendly, because when the underlying type changes, the code using std::underlying_type_t will automatically use the new type.

然而,这有时不是你想要的:假设你想直接打印出枚举值,例如std::cout,如下例所示:

enum class EnumType : int { Green, Blue, Yellow };
std::cout << static_cast<std::underlying_type_t<EnumType>>(EnumType::Green);

如果你稍后将底层类型更改为字符类型,例如uint8_t,那么EnumType::Green的值将不会作为数字打印,而是作为字符打印,这很可能不是你想要的。因此,您有时更愿意将枚举值转换为类似于“底层类型,但在必要时使用整数提升”的类型。

如果需要,可以对强制转换的结果应用一元运算符+来强制提升整数。然而,你也可以使用std::common_type_t(同样来自头文件<type_traits>)来做以下事情:

enum class EnumType : int { Green, Blue, Yellow };
std::cout << static_cast<std::common_type_t<int, std::underlying_type_t<EnumType>>>(EnumType::Green);

最好将这个表达式包装在某个helper模板函数中:

template <class E>
constexpr std::common_type_t<int, std::underlying_type_t<E>>
enumToInteger(E e) {
    return static_cast<std::common_type_t<int, std::underlying_type_t<E>>>(e);
}

这样看起来更友好,对底层类型的更改维护更友好,并且不需要使用operator+的技巧:

std::cout << enumToInteger(EnumType::Green);

不。没有自然的方法。

事实上,在c++ 11中使用强类型枚举类的动机之一是防止它们无声地转换为int。

没有隐式转换(通过设计)的原因在其他答案中给出了。

我个人使用一元操作符+从枚举类转换到它们的底层类型:

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

正如许多人所说,没有办法在不增加开销和太多复杂性的情况下自动转换,但是如果在某个场景中要多使用一些强制转换,则可以通过使用lambdas来减少输入并使其看起来更好。这将增加一些函数调用开销,但与下面看到的长static_cast字符串相比,将使代码更具可读性。这可能不适用于项目范围,但只适用于类范围。

#include <bitset>
#include <vector>

enum class Flags { ......, Total };
std::bitset<static_cast<unsigned int>(Total)> MaskVar;
std::vector<Flags> NewFlags;

-----------
auto scui = [](Flags a){return static_cast<unsigned int>(a); };

for (auto const& it : NewFlags)
{
    switch (it)
    {
    case Flags::Horizontal:
        MaskVar.set(scui(Flags::Horizontal));
        MaskVar.reset(scui(Flags::Vertical)); break;
    case Flags::Vertical:
        MaskVar.set(scui(Flags::Vertical));
        MaskVar.reset(scui(Flags::Horizontal)); break;

   case Flags::LongText:
        MaskVar.set(scui(Flags::LongText));
        MaskVar.reset(scui(Flags::ShorTText)); break;
    case Flags::ShorTText:
        MaskVar.set(scui(Flags::ShorTText));
        MaskVar.reset(scui(Flags::LongText)); break;

    case Flags::ShowHeading:
        MaskVar.set(scui(Flags::ShowHeading));
        MaskVar.reset(scui(Flags::NoShowHeading)); break;
    case Flags::NoShowHeading:
        MaskVar.set(scui(Flags::NoShowHeading));
        MaskVar.reset(scui(Flags::ShowHeading)); break;

    default:
        break;
    }
}