How do I write a maintainable, fast, compile-time bit-mask in C++?

The optimization you're looking for seems to be loop peeling, which is enabled at -O3, or manually with -fpeel-loops. I'm not sure why this falls under the purview of loop peeling rather than loop unrolling, but possibly it's unwilling to unroll a loop with nonlocal control flow inside it (as there is, potentially, from the range check).

By default, though, GCC stops short of being able to peel all the iterations, which apparently is necessary. Experimentally, passing -O2 -fpeel-loops --param max-peeled-insns=200 (the default value is 100) gets the job done with your original code: https://godbolt.org/z/NNWrga

if using only C++11 is a must (&a)[N] is a way to capture arrays. This allows you to write one single recursive function without using helper functions whatsoever:

template <std::size_t N> constexpr std::uint64_t generate_mask(Flags const (&a)[N], std::size_t i = 0u){ return i < N ? (1ull << a[i] | generate_mask(a, i + 1u)) : 0ull; } 

assigning it to a constexpr auto:

void apply_known_mask(std::bitset<64>& bits) { constexpr const Flags important_bits[] = { B, D, E, H, K, M, L, O }; constexpr auto m = generate_mask(important_bits); //< here bits &= m; } 

Test

int main() { std::bitset<64> b; b.flip(); apply_known_mask(b); std::cout << b.to_string() << '\n'; } 

Output

0000000000000000000000000000000000101110010000000000000100100100 // ^ ^^^ ^ ^ ^ ^ // O MLK H E D B 

one really has to appreciate C++`s ability to calculate anything turing computable at compile time. It surely still blows my mind (<>).

For the later versions C++14 and C++17 yakk's answer already wonderfully covers that.

I would encourage you to write a proper EnumSet type.

Writing a basic EnumSet<E> in C++14 (onwards) based on std::uint64_t is trivial:

template <typename E> class EnumSet { public: constexpr EnumSet() = default; constexpr EnumSet(std::initializer_list<E> values) { for (auto e : values) { set(e); } } constexpr bool has(E e) const { return mData & mask(e); } constexpr EnumSet& set(E e) { mData |= mask(e); return *this; } constexpr EnumSet& unset(E e) { mData &= ~mask(e); return *this; } constexpr EnumSet& operator&=(const EnumSet& other) { mData &= other.mData; return *this; } constexpr EnumSet& operator|=(const EnumSet& other) { mData |= other.mData; return *this; } private: static constexpr std::uint64_t mask(E e) { return std::uint64_t(1) << e; } std::uint64_t mData = 0; }; 

This allows you to write simple code:

void apply_known_mask(EnumSet<Flags>& flags) { static constexpr EnumSet<Flags> IMPORTANT{ B, D, E, H, K, M, L, O }; flags &= IMPORTANT; } 

In C++11, it requires some convolutions, but remains possible nonetheless:

template <typename E> class EnumSet { public: template <E... Values> static constexpr EnumSet make() { return EnumSet(make_impl(Values...)); } constexpr EnumSet() = default; constexpr bool has(E e) const { return mData & mask(e); } void set(E e) { mData |= mask(e); } void unset(E e) { mData &= ~mask(e); } EnumSet& operator&=(const EnumSet& other) { mData &= other.mData; return *this; } EnumSet& operator|=(const EnumSet& other) { mData |= other.mData; return *this; } private: static constexpr std::uint64_t mask(E e) { return std::uint64_t(1) << e; } static constexpr std::uint64_t make_impl() { return 0; } template <typename... Tail> static constexpr std::uint64_t make_impl(E head, Tail... tail) { return mask(head) | make_impl(tail...); } explicit constexpr EnumSet(std::uint64_t data): mData(data) {} std::uint64_t mData = 0; }; 

And is invoked with:

void apply_known_mask(EnumSet<Flags>& flags) { static constexpr EnumSet<Flags> IMPORTANT = EnumSet<Flags>::make<B, D, E, H, K, M, L, O>(); flags &= IMPORTANT; } 

Even GCC trivially generates an and instruction at -O1 godbolt:

apply_known_mask(EnumSet<Flags>&): and QWORD PTR [rdi], 775946532 ret 

Since C++11 you could also use classic TMP technique:

template<std::uint64_t Flag, std::uint64_t... Flags> struct bitmask { static constexpr std::uint64_t mask = bitmask<Flag>::value | bitmask<Flags...>::value; }; template<std::uint64_t Flag> struct bitmask<Flag> { static constexpr std::uint64_t value = (uint64_t)1 << Flag; }; void apply_known_mask(std::bitset<64> &bits) { constexpr auto mask = bitmask<B, D, E, H, K, M, L, O>::value; bits &= mask; } 

Link to Compiler Explorer: https://godbolt.org/z/Gk6KX1

The advantage of this approach over template constexpr function is that it's potentially slightly faster to compile due to rule of Chiel.

There are some far to 'clever' ideas here. You are probably not helping maintainability by following them.

is

{B, D, E, H, K, M, L, O}; 

so much easier to write than

(B| D| E| H| K| M| L| O); 

?

Then none of the rest of the code is needed.