如何在C ++中编写可维护的，快速的编译时位掩码？

我有一些或多或少像这样的代码：

#include <bitset>

enum Flags { A = 1, B = 2, C = 3, D = 5,
             E = 8, F = 13, G = 21, H,
             I, J, K, L, M, N, O };

void apply_known_mask(std::bitset<64> &bits) {
    const Flags important_bits[] = { B, D, E, H, K, M, L, O };
    std::remove_reference<decltype(bits)>::type mask{};
    for (const auto& bit : important_bits) {
        mask.set(bit);
    }

    bits &= mask;
}

Clang> = 3.6做聪明的事情，并将其编译为一条and指令（然后在其他任何地方内联）：

apply_known_mask(std::bitset<64ul>&):  # @apply_known_mask(std::bitset<64ul>&)
        and     qword ptr [rdi], 775946532
        ret

但是我尝试过的每个版本的GCC都会将其编译成一个巨大的混乱，其中包括应该静态DCE进行的错误处理。在其他代码中，它甚至会将important_bits等效的数据放在代码中！

.LC0:
        .string "bitset::set"
.LC1:
        .string "%s: __position (which is %zu) >= _Nb (which is %zu)"
apply_known_mask(std::bitset<64ul>&):
        sub     rsp, 40
        xor     esi, esi
        mov     ecx, 2
        movabs  rax, 21474836482
        mov     QWORD PTR [rsp], rax
        mov     r8d, 1
        movabs  rax, 94489280520
        mov     QWORD PTR [rsp+8], rax
        movabs  rax, 115964117017
        mov     QWORD PTR [rsp+16], rax
        movabs  rax, 124554051610
        mov     QWORD PTR [rsp+24], rax
        mov     rax, rsp
        jmp     .L2
.L3:
        mov     edx, DWORD PTR [rax]
        mov     rcx, rdx
        cmp     edx, 63
        ja      .L7
.L2:
        mov     rdx, r8
        add     rax, 4
        sal     rdx, cl
        lea     rcx, [rsp+32]
        or      rsi, rdx
        cmp     rax, rcx
        jne     .L3
        and     QWORD PTR [rdi], rsi
        add     rsp, 40
        ret
.L7:
        mov     ecx, 64
        mov     esi, OFFSET FLAT:.LC0
        mov     edi, OFFSET FLAT:.LC1
        xor     eax, eax
        call    std::__throw_out_of_range_fmt(char const*, ...)

我应该如何编写此代码，以便两个编译器都能正确执行操作？失败了，我应该怎么写，以使其保持清晰，快速和可维护？

最佳版本是 C ++ 17：

template< unsigned char... indexes >
constexpr unsigned long long mask(){
  return ((1ull<<indexes)|...|0ull);
}

然后

void apply_known_mask(std::bitset<64> &bits) {
  constexpr auto m = mask<B,D,E,H,K,M,L,O>();
  bits &= m;
}

早在 C ++ 14，我们可以做这个奇怪的把戏：

template< unsigned char... indexes >
constexpr unsigned long long mask(){
  auto r = 0ull;
  using discard_t = int[]; // data never used
  // value never used:
  discard_t discard = {0,(void(
    r |= (1ull << indexes) // side effect, used
  ),0)...};
  (void)discard; // block unused var warnings
  return r;
}

或者，如果我们坚持 C ++ 11，我们可以递归解决：

constexpr unsigned long long mask(){
  return 0;
}
template<class...Tail>
constexpr unsigned long long mask(unsigned char b0, Tail...tail){
  return (1ull<<b0) | mask(tail...);
}
template< unsigned char... indexes >
constexpr unsigned long long mask(){
  return mask(indexes...);
}

Godbolt与所有这3个 -您可以切换CPP_VERSION定义，并获得相同的装配。

在实践中，我会尽量使用最现代的。14击败11，因为我们没有递归，因此符号长度为O（n ^ 2）（这可能会爆炸编译时间和编译器内存使用情况）；17比14好，因为编译器不必通过死代码消除该数组，并且该数组技巧很丑陋。

在这14个中，最令人困惑的是。在这里，我们创建一个全为0的匿名数组，同时作为副作用构造我们的结果，然后丢弃该数组。丢弃的数组中包含等于包装大小的0，等于1，再加上1（我们添加了数字，以便处理空包装）。

关于什么的详细说明 C ++ 14版本正在做。这是一个trick俩/技巧，而您必须这样做才能在C ++ 14中高效地扩展参数包，这是在其中添加折叠表达式的原因之一C ++ 17。

最好由内而外的理解：

    r |= (1ull << indexes) // side effect, used

这只是更新r有1<<indexes一个固定的指标。 indexes是一个参数包，因此我们必须对其进行扩展。

剩下的工作是提供一个参数包以在其中扩展indexes。

迈出一步：

(void(
    r |= (1ull << indexes) // side effect, used
  ),0)

在这里，我们将表达式转换为void，表示我们不在乎其返回值（我们只希望set 的副作用r-在C ++中，类似的表达式a |= b也返回它们设置的值a为）。

然后，我们使用逗号运算符,并0丢弃void“值”，然后返回value 0。因此，这是一个表达式，其值为0和作为计算的副作用，0它在中设置了一位r。

  int discard[] = {0,(void(
    r |= (1ull << indexes) // side effect, used
  ),0)...};

此时，我们扩展参数pack indexes。这样我们得到：

 {
    0,
    (expression that sets a bit and returns 0),
    (expression that sets a bit and returns 0),
    [...]
    (expression that sets a bit and returns 0),
  }

在{}。这种使用的,是不逗号运算符，而是在阵列元件隔板。这是sizeof...(indexes)+1 0s，这也将bit设置r为副作用。然后，我们将{}数组构造指令分配给数组discard。

接下来，我们转换discard为void-如果您创建变量并且从不读取，大多数编译器都会警告您。如果将其强制转换为void，所有编译器都不会抱怨，这是一种表示“是的，我知道，我没有使用它”的方式，因此它可以消除警告。

您正在寻找的优化似乎是循环剥皮，可在-O3或手动启用-fpeel-loops。我不确定为什么它属于循环剥离而不是循环展开的范围，但是可能不愿意展开其中包含非本地控制流的循环（因为可能存在范围检查）。

不过，默认情况下，GCC停止了剥离所有迭代的工作，这显然是必要的。在实验上，传递-O2 -fpeel-loops --param max-peeled-insns=200（默认值为100）可使用原始代码完成工作：https : //godbolt.org/z/NNWrga

如果仅使用C ++ 11是必须的(&a)[N]捕获数组的方法。这使您无需使用辅助函数就可以编写一个递归函数：

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;
}

将其分配给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;
}

测试

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

输出量

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

人们确实必须欣赏C ++在编译时计算可计算的任何东西的能力。它肯定仍然让我大吃一惊（<>）。

对于更高版本的C ++ 14和C ++ 17，yakk的答案已经很好地涵盖了这一点。

我鼓励你写一个合适的 EnumSet类型。

EnumSet<E>基于C ++ 14（或更高版本）编写基础std::uint64_t很简单：

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;
};

这使您可以编写简单的代码：

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

    flags &= IMPORTANT;
}

在C ++ 11中，它需要一些卷积，但是仍然可能：

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;
};

与一起调用：

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;
}

甚至GCC都会and在-O1 Godbolt上微不足道地产生一条指令：

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

从C ++ 11开始，您还可以使用经典的TMP技术：

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;
}

链接到编译器资源管理器：https : //godbolt.org/z/Gk6KX1

这种方法优于模板constexpr函数的优点是，由于Chiel的规则，它的编译速度可能会稍微快一些。

这里有一些“聪明”的想法。您可能无法通过遵循它们来帮助维护它们。

是

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

比写起来容易得多

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

？

然后，不需要其余的代码。