标签: enum-class

我已经看到过reinterpret_cast常用于对枚举类应用增量,我想知道这种用法在标准C++中是否可以接受.

enum class Foo : int8_t
{
    Bar1,
    Bar2,
    Bar3,
    Bar4,

    First = Bar1,
    Last = Bar4
};

for (Foo foo = Foo::First; foo <= Foo::Last; ++reinterpret_cast<int8_t &>(foo))
{
    ...
}

我知道,如果是普通的类,那么转换为基类的引用是安全的.但由于枚举类不是隐式转换为其底层类型的事件,因此我不确定上述代码是否以及如何保证在所有编译器中都能正常工作.有线索吗？

clang 6.0.0接受以下代码,但gcc 8.2拒绝

enum class E {
  Good, Bad,
};

struct S {
  E e : 2;
  int dummy;
};

S f() {
  return {E::Good, 100};
}

直播godbolt的例子

海湾合作委员会抱怨

错误:无法将' {Good, 100}'从' <brace-enclosed initializer list>' 转换为' S'

哪一个是正确的？标准中哪里谈到这种情况？

在State.h我有

enum class StateID : unsigned int;

在State.cpp我有

enum class StateID : unsigned int
{
    NullID = 0,
    MainMenuID,
    GamePlayID,
};

问题是任何包含的类State.h都有前向声明,但我不能enum在任何cpp文件中使用任何值,除了States.cpp(定义它),比如StateID::MainMenuID.错误说......

/home/lee/Projects/SuddenAwakening/Source/Game.cpp:24:错误:'MainMenuID'不是'StateID'的成员

我正在运行LinuxMint15KDE,g ++ 4.7,我在其他部分使用c ++ 11功能,如nullptr,unique_ptr,ect ......,所以我不会忘记c ++ 11的编译器标志.

我正在使用a std::tuple并定义了一个类枚举,以某种方式"命名"每个元组的字段,忘记了它们的实际索引.

所以不要这样做:

std::tuple<A,B> tup;
/* ... */
std::get<0>(tup) = bleh; // was it 0, or 1?

我这样做了:

enum class Something {
     MY_INDEX_NAME = 0,
     OTHER_INDEX_NAME
};

std::tuple<A,B> tup;
/* ... */
std::get<Something::MY_INDEX_NAME> = 0; // I don't mind the actual index...

问题是,由于使用gcc 4.5.2编译,我现在安装了4.6.1版本,我的项目无法编译.此代码段会重现错误:

#include <tuple>
#include <iostream>

enum class Bad {
    BAD = 0
};

enum Good {
    GOOD = 0
};

int main() {
    std::tuple<int, int> tup(1, 10);
    std::cout << std::get<0>(tup) << std::endl;
    std::cout << std::get<GOOD>(tup) << …

我有一个像这样的枚举类:

    typedef unsigned int binary_instructions_t;

    enum class BinaryInstructions : binary_instructions_t
    {
        END_INSTRUCTION = 0x0,

        RESET,

        SET_STEP_TIME,
        SET_STOP_TIME,
        START,

        ADD
    };

我试图在这样的switch语句中使用枚举的成员:

const std::string& function(binary_instructions_t arg, bool& error_detect)
{
    switch(arg)
    {
        case (unsigned int)BinaryInstructions::END_INSTRUCTION:
            return "end";
        break;
    }
    translate_error = true;
    return "ERROR";
}

(unsigned int)当底层类型已经是一个时,为什么需要强制转换unsigned int？

我试图将一个枚举类包装在c ++头文件中,以便在cython项目中使用.我已经google了一下,无法找到如何实现这一点 - 是否支持？

让我们说我疯了,并决定创造以下怪物:

#include <type_traits>
#include <iostream>

// Utility proxy type - convertible back to E but also permits bool conversion
// for use in conditions.
// 
//  e.g.
//   Foo f = Foo::Bar & Foo::Baz;
//   if (f & Foo::Baz) { /* ... */ }
// 
template <typename E, typename = std::enable_if_t<std::is_enum_v<E>, void>>
struct EnumToBoolProxy
{   
    operator E() const
    {
        return _val;
    }

    explicit operator bool()
    {
        using UT = std::underlying_type_t<E>;
        return static_cast<UT>(_val) != 0;
    }

private:
    const E _val;

    EnumToBoolProxy(const …

我基本上有两个问题可能是相关的,所以我将它们合二为一.

我们应该在传递给函数时通过引用或值传递C++ 11中的枚举类.它继承了原始类型,但它是通过的整个对象吗？因为枚举类是安全的;

enum class MyEnumClass : unsigned short {
    Flag1 = 0,
    Flag2 = 1,
    Flag3 = 2,
    Flag4 = 4,
};

现在让我们说我们有功能sig

const char* findVal(const MyEnumClass& enumClass);
                                     ^
    should this be by const ref?   __|

我的另一个问题是 -

SHOULD IT BE BY MOVE like (MyEnumClass&&) - I am still learning/understanding 
move semantics and rvalue so I am not sure if move semantics are only for 
constructors or can be for member or static funcs -

我通常使用enum'bit-or'或|一起允许对象有一些选项.如何让enum类使用'bit-or'功能？

我在g ++ 4.8.1和clang ++ 3.4的行为之间存在差异.

我有一个A文字类型的类,它有一个explicit constexpr转换函数可以输入enum class E.

Gcc允许我在某些情况下使用转换函数从constexpr类型E的常量表达式初始化类型A的变量,但不是在变量是静态类成员时(e2下面)

Clang拒绝所有上下文(e1,e2和e3)中的初始化.

根据[over.match.conv]p1使用显式转换功能可以在这里

enum class E { e };
struct A { explicit constexpr operator const E() const noexcept { return E::e; } };

constexpr E e1{A{}};                      // Gcc: OK, Clang: Error
struct B { static constexpr E e2{A{}}; }; // Gcc: Error, Clang: Error
void f() { static …