c++ - 在C++中使循环变量成为常量

Question

我目前正在为高级综合创建算术运算符库。

为此，我还创建了一个库来像在 VHDL 中那样操作位和位 vector 。为了使我的库可综合，几乎所有的事情都必须在编译时解决。

但是，我遇到了循环问题。

的确，我希望能够写出这样的东西:

const int N = 5;
for(int i = 0; i < N-2; i++) {
    x.bit<i+2>() = x.bit<i>();
}

当然，它不会编译，因为 i 是一个变量，而不是编译时确定的常量。

然而，N 是一个常量，这段代码严格等价于:

x.bit<2>() = x.bit<0>();
x.bit<3>() = x.bit<1>();
x.bit<4>() = x.bit<2>();

它可以完美地编译和运行。

有没有办法让编译器(在我的例子中是 gcc)展开循环，因为 N 是常量？或者定义一个宏或一个 constexpr 可以用干净的语法来完成？这相当于 VHDL 中的for generate。

Answer 1

同时 constexpr在 C++14/17 中变得更加强大，目前还不可能将这种编译时/模板代码与普通循环混合使用。有一些关于引入可能在未来版本的 C++ 中启用该功能的构造的讨论。现在你有几个选择，要么递归调用一个带有整数模板参数的函数，要么在这种情况下更简单的 C++17 fold expression .您还可以使用 C++11 可变参数模板扩展来获得与此示例中的折叠表达式类似的结果，尽管折叠表达式更强大。

刚刚看到您关于受困于 C++11 的评论，我认为您最好使用递归函数方法。我已将该方法添加到示例中。

如果您能够使用 C++14，您可能还想考虑完全迁移到 constexpr功能/类型土地所以你的bit<I>()函数不会被模板化，而只是一个 constexpr函数 bit(i) .然后您可以使用正常的函数和循环。考虑到 C++11 对 constexpr 的限制但是，在您的情况下可能用处不大的功能。我添加了一个使用该方法的示例。

#include <iostream>
#include <utility>

template <size_t N>
struct bits {
    bool bs[N];

    template <size_t I>
    constexpr const bool& bit() const {
        return bs[I];
    }
    template <size_t I>
    constexpr bool& bit() {
        return bs[I];
    }

    constexpr bool bit(int i) const { return bs[i]; }
    constexpr void bit(int i, bool x) { bs[i] = x; }
};

// Using C++17 fold expressions

template <size_t N, size_t... Is>
constexpr bits<N> set_bits_helper(bits<N> x, std::index_sequence<Is...>) {
    ((x.bit<Is + 2>() = x.bit<Is>()), ...);
    return x;
}

template <size_t N>
constexpr bits<N> set_bits(bits<N> x) {
    return set_bits_helper(x, std::make_index_sequence<N - 2>{});
}

// Using recursive template function, should work on C++11

template <size_t I, size_t N>
constexpr bits<N> set_bits_recursive_helper(bits<N> x, std::integral_constant<size_t, I>) {
    x.bit<N - I>() = x.bit<N - I - 2>();
    return set_bits_recursive_helper(x, std::integral_constant<size_t, I - 1>{});
}

template <size_t N>
constexpr bits<N> set_bits_recursive_helper(bits<N> x, std::integral_constant<size_t, 0>) { return x; }

template <size_t N>
constexpr bits<N> set_bits_recursive(bits<N> x) {
    return set_bits_recursive_helper(x, std::integral_constant<size_t, N - 2>{});
}

// Using non template constexpr functions
template <size_t N>
constexpr bits<N> set_bits_constexpr(bits<N> x) {
    for (int i = 0; i < N - 2; ++i) {
        x.bit(i + 2, x.bit(i));
    }
    return x;
}

// Test code to show usage

template <size_t N>
void print_bits(const bits<N>& x) {
    for (auto b : x.bs) {
        std::cout << b << ", ";
    }
    std::cout << '\n';
}

void test_set_bits() {
    constexpr bits<8> x{ 1, 0 };
    print_bits(x);
    constexpr auto y = set_bits(x);
    static_assert(y.bit<2>() == x.bit<0>());
    print_bits(y);
}

void test_set_bits_recursive() {
    constexpr bits<8> x{ 1, 0 };
    print_bits(x);
    constexpr auto y = set_bits_recursive(x);
    static_assert(y.bit<2>() == x.bit<0>());
    print_bits(y);
}

void test_set_bits_constexpr() {
    constexpr bits<8> x{ 1, 0 };
    print_bits(x);
    constexpr auto y = set_bits_constexpr(x);
    static_assert(y.bit<2>() == x.bit<0>());
    print_bits(y);
}

int main() {
    test_set_bits();
    test_set_bits_recursive();
    test_set_bits_constexpr();
}