标签: enum-class

可以这样做吗？

enum A
{
    enum B
    {
        SOMETHING1,
        SOMETHING2
    };

    enum C
    {
        SOMETHING3,
        SOMETHING4
    };
};

如果没有,是否有替代解决方案？

这个问题的目的:想要/需要能够做这样的事情:

enum class ElementaryParticleTypes
{

    enum class MATTER
    {
        enum class MESONS
        {
            PI
        };

        enum class BARYONS
        {
            PROTON,
            NEUTRON
        };

        enum class LEPTONS
        {
            ELECTRON
        };
    };

    enum class ANTI_MATTER
    {
        enum class ANTI_MESONS
        {
            ANTI_PI
        };

        enum class ANTI_BARYONS
        {
            ANTI_PROTON
            ANTI_NEUTRON
        };

        enum class ANTI_LEPTONS
        {
            POSITRON
        };
    };

};

希望使用强类型功能.

为什么以及如何运作？什么类型的'自动'在这里？

auto lambda = [](){
    enum class Local { X=0 };
    return Local::X;
};

auto x = lambda(); // No error! Why and what type is auto in this case?
auto y = Local::X; // Error! Of course!

该enum class Local不拉姆达类型以外公知的.它是一个enum class,因此不能没有int演员阵容,AFAIK.如何返回本地类型auto以及它在lambda之外的类型是什么？

我在C++ 11中有以下类:

class MyTable
{
    public:
    enum class EntryType
    {
        USED, FREE
    };

    MyTable(EntryType value)
    {
        for (uint32_t i = 0; i < 10; ++i)
        {
            memset(_table[i].data(), (int)value, sizeof(_table[0][0]) * 50);
        }
    }
    array<array<EntryType, 50>, 10> _table;
}

尝试使用EntryType :: FREE的值构造MyTable的对象,二维数组中的每个项的值都为0x01010101(每8位1b),而不是仅为0x1的预期值

我猜它与我的value被投入有关int,但我不知道为了解决这个问题我应该做些什么.

假设有一个使用枚举类的C++ 11 API:

// api.hpp
enum class E {A, B, C};
void f(E);
...

// api.cpp
void f(E e)
{
    if (e == E::A)
       ...
}

现在假设我想使用这个API,但我没有C++ 11编译器.所以我:

• 修改api.hpp枚举类并将其更改为常规枚举.
• 编写一些包含修改后的代码,api.hpp并正常使用API​​(例如调用f).
• 使用我的非C++ 11编译器编译此代码,并将其链接到使用C++ 11编译器编译的API实现(使用未修改的编译器api.hpp).

这似乎与海湾合作委员会有关,但一般来说是安全的,还是我玩火(ODR违规等)？

假设两个编译器在其他方面是链接兼容的,那么只有enum vs. enum类才有问题.

对于一个从未写过一行C++ 11,并且目前没有机会用C++ 11编程的人,你能用一个简短的段落告诉我:

什么是"枚举类",为什么我们需要它？

我最近开始使用C++/CLI托管代码,但我总是定义这样的枚举:

enum FV_MODE
{
    IDLE,DRAG,ADD_HITBOX,ADD_HURTBOX
};

直到今天,当我遇到错误消息:

cannot define an unmanaged enum 'FViewer::FV_MODE' inside managed 'FViewer'
1>          use 'enum class'

正如消息和各种Stack Overflow问题中所建议的那样,将我的代码更改为:

enum class FV_MODE
{
    IDLE,DRAG,ADD_HITBOX,ADD_HURTBOX
};

迅速解决了问题.

但是,我仍然没有意识到我现在知道定义枚举的两种不同方式之间的差异.有人可以帮我澄清一下吗？还有什么使"枚举类"更适合托管代码？

提前致谢,

家伙

让我说我有

enum class Flags : std::uint16_t
{
    None = 0,
    A    = 0x0001,
    B    = 0x0002,
    C    = 0x0004
}

inline Flags operator|(Flags lhs, Flags rhs)
{
    return static_cast<Flags>(static_cast<std::uint16_t>(lhs) | static_cast<std::uint16_t>(rhs));
}

inline Flags operator&(Flags lhs, Flags rhs)
{
    return static_cast<Flags>(static_cast<std::uint16_t>(lhs) & static_cast<std::uint16_t>(rhs));
}

inline Flags operator|=(Flags& lhs, Flags rhs)
{
    return lhs = lhs | rhs;
}

inline Flags operator&=(Flags& lhs, Flags rhs)
{
    return lhs = lhs & rhs;
}

是否有可能使枚举类在上下文中可转换为bool以允许某人执行

Flags f = /* ... */;
if …

在类中编写枚举的正确方法是什么？我正在用 C++ 编写康威的生命游戏代码。所以我有一个模式类，其中包含有关不同类型模式的信息：

class Patterns
{
public:
    Patterns();
    ~Patterns(void);

private:
    enum class PatternType
    {
        bloat,
        block,
        blinker,
        toad
    };

    PatternType pattern_;
};

我的目标不是污染这里的全球空间。这就是在类内部编写枚举的编写方式，同时牢记 oops 概念。如果没有，请建议一些更好的替代方法以及它们相对于此方法的好处是什么。欢迎任何有关在类中编写枚举时记住事项的意见。

编辑：@Jay Miller 根据他的输入，我尝试了他的所有三种方法

class Patterns
{
public:
    Patterns();
    ~Patterns(void);

private:
    enum class PatternType
    {
        bloat,
        block,
        blinker,
        toad
    };

    PatternType pattern_;
};

我的发现（在尝试了代码并谷歌搜索了一下之后）：

1. 在我的例子中，PatternSimple 是在类内部编写枚举的最简单方法；但它会损害类型安全性，即我可以将枚举值与任何其他数据类型进行比较，并且不会给出任何错误。
2. PatternClassIn 提供类型安全；但我必须在调用函数中编写更多代码才能访问枚举值。
3. PatternClassOut 提供了两全其美的方法。它提供了类型安全性，此外，调用函数访问枚举值的代码与PatternSimple相同。

我想用a unordered_map<std::pair<enum_class,other_enum_class>,std::uint8_t>来管理一些像素图格式.

这里的最小代码:

#include <unordered_map>
#include <utility>
#include <cstdint> 
#include <iostream>
#include <functional>

enum class PNM : std::uint8_t { PBM, PGM, PPM };
enum class Format : bool      { BIN, ASCII };

struct pair_hash {
public:
    template <typename T, typename U>
    std::size_t operator()(const std::pair<T, U> &x) const { 
        return std::hash<T>()(x.first) ^ std::hash<U>()(x.second); 
    }
};

int main(){

    std::unordered_map<std::pair<PNM, Format>, std::uint8_t, pair_hash> k_magic_number ({
        { { PNM::PBM, Format::BIN   }, 1 }, { { PNM::PGM, Format::BIN   }, 2 }, { { PNM::PPM, …

我通过创建一个枚举类定义了一个元组及其索引：

/** parameter { key ; value1 ; value1 ; } */
using Parameter = std::tuple<unsigned, unsigned, unsigned>;
enum class ParameterKey : std::size_t {
    KEY = 0,
    VALUE1 = 1,
    VALUE2 = 2
};

现在我想从这个元组中得到一个值：

const auto& key = std::get<ParameterKey::KEY>(*parameterPointer);

我认为从intto的隐式转换std::size_t是由: std::size_t语法确保的：

enum class ParameterKey : std::size_t {
    ....
}

但我收到了这个错误

error: no matching function for call to ‘get<KEY>(std::tuple<unsigned int, unsigned int, unsigned int>&)’

这工作正常，但它太啰嗦了：

const auto& key = std::get<static_cast<unsigned>(ParameterKey::KEY)>(*parameterPointer);