假设10
是一个编译时间常数......
#include <cstddef>
#include <utility>
template<std::size_t N>
struct do_N_times_type {
template<typename Lambda>
void operator()( Lambda&& closure ) const {
closure();
do_N_times_type<N-1>()(std::forward<Lambda>(closure));
}
};
template<>
struct do_N_times_type<1> {
template<typename Lambda>
void operator()( Lambda&& closure ) const {
std::forward<Lambda>(closure)();
}
};
template<>
struct do_N_times_type<0> {
template<typename Lambda>
void operator()( Lambda&& closure ) const {
}
};
template<std::size_t N, typename Lambda>
void do_N_times( Lambda&& closure ) {
do_N_times_type<N>()( std::forward<Lambda>(closure) );
};
#include <iostream>
void f() {
std::cout << "did it!\n";
}
int main() {
do_N_times<10>([&]{
f();
});
}
要不就
int main() {
do_N_times<10>(f);
}
其他荒谬的方法:
编写一个范围迭代器(我称之为 mine index
),它产生一系列迭代器-on-integral 类型(我默认为std::size_t
)。然后输入:
for( auto _:index_range(10) )
它使用变量 ( _
) 但看起来非常混乱。
另一种疯狂的方法是创建一个类似 python 的生成器。编写一个生成器包装器,它接受一个可迭代的范围并生成一个返回std::optional
该value_type
范围的函数并不棘手。
然后我们可以这样做:
auto _ = make_generator( index_range(10) );
while(_()) {
}
它也创建了一个临时变量,而且更加迟钝。
我们可以编写一个在生成器上运行的循环函数:
template<typename Generator, typename Lambda>
void While( Generator&& g, Lambda&& l ) {
while(true) {
auto opt = g();
if (!opt) return;
l(*opt);
}
}
然后我们称之为:
While( make_generator( index_range(10) ), [&](auto&&){
f();
});
但这两者都在函数中创建了一些临时变量,并且比上一个更荒谬,并且依赖于甚至尚未最终确定的 C++1y 的特性。
那些我试图创建一种无变量的方式来重复某件事 10 次的地方。
但实际上,我只是做循环。
您几乎可以肯定地通过键入来阻止警告x=x;
或者写一个函数
template<typename Unused>
void unused( Unused&& ) {}
并调用unused(x);
-- 变量x
被使用,它的名字被放到里面,所以编译器可能不会在里面警告你。
所以试试这个:
template<typename Unused>
void unused( Unused&& ) {}
for(int x{};x<10;++x) {
unused(x);
f();
}
这应该抑制警告,并且实际上很容易理解。