如何在 C 中使用枚举作为标志？

Question

通过 [Flags] 属性在 C# 中将 enum s 视为标志可以很好地工作，但是在 C++ 中执行此操作的最佳方法是什么？

例如，我想写：

 enum AnimalFlags
{
    HasClaws = 1,
    CanFly =2,
    EatsFish = 4,
    Endangered = 8
};

seahawk.flags = CanFly | EatsFish | Endangered;

但是，我收到有关 int / enum 转换的编译器错误。有没有比直截了当的铸造更好的方式来表达这一点？最好，我不想依赖来自 3rd 方库（如 boost 或 Qt）的构造。

编辑：如答案所示，我可以通过将 seahawk.flags 声明为 int 来避免编译器错误。但是，我想有一些机制来强制类型安全，所以有人不能写 seahawk.flags = HasMaximizeButton 。

原文由 Tony the Pony 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

“正确”的方法是为枚举定义位运算符，如：

 enum AnimalFlags
{
    HasClaws   = 1,
    CanFly     = 2,
    EatsFish   = 4,
    Endangered = 8
};

inline AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
    return static_cast<AnimalFlags>(static_cast<int>(a) | static_cast<int>(b));
}

等等其余的位运算符。如果枚举范围超出 int 范围，则根据需要进行修改。

原文由 eidolon 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

这是一个惰性 C++11 解决方案， 它不会 改变枚举的默认行为。它也适用于 enum struct 和 enum class ，并且是 constexpr 。

 #include <type_traits>

template<class T = void> struct enum_traits {};

template<> struct enum_traits<void> {
    struct _allow_bitops {
        static constexpr bool allow_bitops = true;
    };
    using allow_bitops = _allow_bitops;

    template<class T, class R = T>
    using t = typename std::enable_if<std::is_enum<T>::value and
        enum_traits<T>::allow_bitops, R>::type;

    template<class T>
    using u = typename std::underlying_type<T>::type;
};

template<class T>
constexpr enum_traits<>::t<T> operator~(T a) {
    return static_cast<T>(~static_cast<enum_traits<>::u<T>>(a));
}
template<class T>
constexpr enum_traits<>::t<T> operator|(T a, T b) {
    return static_cast<T>(
        static_cast<enum_traits<>::u<T>>(a) |
        static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T> operator&(T a, T b) {
    return static_cast<T>(
        static_cast<enum_traits<>::u<T>>(a) &
        static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T> operator^(T a, T b) {
    return static_cast<T>(
        static_cast<enum_traits<>::u<T>>(a) ^
        static_cast<enum_traits<>::u<T>>(b));
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator|=(T& a, T b) {
    a = a | b;
    return a;
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator&=(T& a, T b) {
    a = a & b;
    return a;
}
template<class T>
constexpr enum_traits<>::t<T, T&> operator^=(T& a, T b) {
    a = a ^ b;
    return a;
}

要为枚举启用按位运算符：

 enum class my_enum {
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    // ...
};

// The magic happens here
template<> struct enum_traits<my_enum> :
    enum_traits<>::allow_bitops {};

constexpr my_enum foo = my_enum::Flag1 | my_enum::Flag2 | my_enum::Flag3;

原文由 ShadowFan-X 发布，翻译遵循 CC BY-SA 4.0 许可协议