#include <functional>
template<typename Number,
typename AdvanceOperation = std::plus<Number>>
class sequence_generator
{
public:
sequence_generator(Number start_value = Number{},
Number step_size = Number{1},
AdvanceOperation advancer = AdvanceOperation{})
: current_value{start_value},
step_size{step_size},
advancer{advancer}
{}
auto operator()()
{
return next();
}
auto next()
{
auto tmp = current_value;
current_value = advancer(current_value, step_size);
return tmp;
}
private:
Number current_value;
Number step_size;
AdvanceOperation advancer;
};
template<typename Number, typename AdvanceOperation=std::plus<Number>>
auto make_sequence_generator(Number start_value, Number step_size,
AdvanceOperation advancer)
{
return sequence_generator<Number, AdvanceOperation>{start_value, step_size,
advancer};
}
#include <algorithm>
#include <iostream>
#include <vector>
#include <cassert>
int main()
{
std::vector<int> vector(10);
std::generate(std::begin(vector), std::end(vector),
sequence_generator<int>{});
assert(vector == std::vector<int>({0,1,2,3,4,5,6,7,8,9}));
std::generate(std::begin(vector), std::end(vector),
make_sequence_generator(1,2,std::multiplies<>{}));
assert(vector == std::vector<int>({1,2,4,8,16,32,64,128,256,512}));
}
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