我目前正在为高级综合创建算术运算符库。
为此,我还创建了一个库来像在 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。
最佳答案
同时 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();
}
关于c++ - 在C++中使循环变量成为常量,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/47111979/