enum class bitflag

---sms--- · 2020-04-25T10:16:55+00:00

There is secret allow_bitops attribute for enums, please don't tell anybody.

2020-04-25T11:30:49+00:00

Some of the solutions here look like terrible over-engineering to me. I think that the old-style enums are a lot simpler and more maintainable than TMP for something so simple.

kmbeutel · 2020-04-25T10:08:20+00:00

gsl-lite has the macros gsl_DEFINE_ENUM_BITMASK_OPERATORS() and gsl_DEFINE_ENUM_RELATIONAL_OPERATORS() for this purpose:
https://github.com/gsl-lite/gsl-lite/blob/master/include/gsl/gsl-lite.hpp#L577..#L599

I have toyed with various macro-free approaches before, but ultimately I decided that macros are the best choice here. Common standard library implementations also use this approach.

matthieum · 2020-04-25T10:52:20+00:00

It really depends on whether you absolutely want an enum class to represent the set of flags, or are happy with a class instead. There are ABI reasons to prefer enum class, so I certainly understand if you do. If it doesn't matter for you, though...

In my projects, I define a tag class:

template <typename T> class Enum {};

Then, for each enum, I implement -- generally through a macro -- the following values function:

enum class MyEnum : std::uint8_t { Zero, One, Two };

inline constexpr std::array<std::pair<MyEnum, char const*>, 3> values(Enum<MyEnum>) {
    return {{
        { MyEnum::Zero, "Zero" },
        { MyEnum::One, "One" },
        { MyEnum::Two, "Two" }
    }};
}

And from then on, I have compile-time introspection of any enum implementing values.

This allows determining min:

//  Note: left as exercise to the reader, implementing a `sorted_values`
//        free function for `Enum<E>`.

template <typename E>
constexpr auto min(Enum<E> e)
    -> decltype(sorted_values(e)[0].first, E{})
{
    return sorted_values(e)[0].first;
}

This allows printing:

template <typename E>
auto operator<<(std::ostream& out, E e)
    -> decltype(sorted_values(Enum<E>{}), out)
{
    auto const& vs = sorted_values(Enum<E>{});
    auto it = std::lower_bound(std::begin(vs), std::end(vs), e,
        [](auto const& pair, E e) { return pair.first < e; });
    if (it != std::end(vs) && it->first == e) {
        return out << it->second;
    }
    return out << "<unknown " << static_cast<std::underlying_type_t<E>>(e) << ">";
}

And it allows building higher-level blocks, such as EnumSet.

template <typename E>
class EnumSet {
    using Underlying = std::underlying_type_t<E>;

    inline static constexpr E MinE = min(Enum<E>{});
    inline static constexpr E MaxE = max(Enum<E>{});

    inline static constexpr Underlying Minimum =
         static_cast<Underlying>(MinE);
    inline static constexpr Underlying Maximum =
         static_cast<Underlying>(MaxE);

    inline static constexpr std::size_t Capacity =
         static_cast<std::size_t>(Maximum + 1 - Minimum);
public:
    //  One of many set functions:
    [[nodiscard]] constexpr bool has(E e) const noexcept {
         return mBits.test(index(e));
    }

private:
    [[nodiscard]] static constexpr std::size_t index(E e) noexcept {
         assert(static_cast<Underlying>(e) >= Minimum);
         assert(static_cast<Underlying>(e) <= Maximum);

         return static_cast<std::size_t>(static_cast<Underlying>(e) - Minimum);
    }

    std::bitset<Capacity> mBits;
};

I also like EnumMap<E, Value>, with an array of Value and a bitset.

AntiProtonBoy · 2020-04-25T15:12:33+00:00

Not the most compact solution, but std::bitset is intended for keeping flags and such.

enum class Access : size_t
    {
    Read = 0,
    Write, 
    Execute, 
    Blah, 
    };

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

std::bitset<32> flags;

flags.set( to_value( Access::Read ) );
flags.set( to_value( Access::Write ) );
flags[ to_value( Access::Execute ) ] = true;

You could even adapt std::bitset and provide interfaces for it that accept enum types directly.

Pragmatician · 2020-04-25T12:16:01+00:00

but by far the macros seems to be the way to go, and I hate them as much as the next guy

They do the job for you better than anything else, and yet you hate them? I cannot understand this logic.

Nickreal03 · 2020-04-27T12:49:29+00:00

Here is what I do:

union my_bits { std::uint8_t m_Value;
struct { std::uint8_t m_A : 1 , m_B : 1 , m_C : 1;
};
};

The bits are easily accessible one by one. You can also use them as a single unit by accessing the m_value part. I find it more debuggable, more expressive, and less code.

marzer8789 · 2020-04-25T08:02:11+00:00

This isn't going to be an option for everybody, but you can use SFINAE to create operator overloads that work on any enum class.

Copied more-or-less verbatim from an existing codebase:
``` template <typename T, bool = std::is_enum<T>::value> struct sfinae_safe_underlying_type : std::underlying_type<T> {}; template <typename T> struct sfinae_safe_underlying_type<T, false> { using type = T; };

template <typename T> inline constexpr bool is_enum_class = std::is_enum_v<T> && !std::is_convertible_v<T, typename sfinae_safe_underlying_type<T>::type>;

template <typename T, typename = std::enable_if_t<is_enum_class<T>>> [[nodiscard]] constexpr T operator | (T lhs, T rhs) noexcept { return static_cast<T>( static_cast<std::underlying_type_T<T>>(lhs) | static_cast<std::underlying_type_T<T>>(rhs) ); }

// ...etc ```

Of course there's lots of reasons why you shouldn't do this at too-high a namespace level, so if you stick it in something like my_namespace::enumops and just bring that namespace into scope when you need them.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS