Binding a templated standard library function - c++

Question

How do you do this? The alternative requires wrapping std::generate in a lambda or std::function and that's undesirable.
int main()
{
using array_int = std::array<int, 10>;
std::vector<array_int> vec(10);
std::for_each(vec.begin(), vec.end(),
std::bind(std::generate, std::placeholders::_1, []() { return 0; }));
return 0;
}
As noted the problem is std::generate takes an iterator pair. Let's pretend they're boost ranges instead:
boost::for_each(vec,
boost::bind(boost::generate, _1, []() { return 0; }));

Answer 1

I assume you're really going to pass something more useful to generate, because those arrays will already be filled with zeros, because vector value-initializes them.
Your bind expression will not pass the right number of arguments to generate, so specifying which specialization of generate you want is not the only problem. In order to state the specialization you need to know the type of the generator you want to pass, which is a lambda, so you need to hoist that out:
auto gen = [] { return 0; };
Then you need to say which generate you want:
std::generate<array_int::iterator, decltype(gen)>
Then you need to pass the right arguments to it:
std::bind(std::generate<array_int::iterator, decltype(gen)>,
std::bind(&array_int::begin, std::placeholders::_1),
std::bind(&array_int::end, std::placeholders::_1),
gen));
This still won't work, because array_int::begin and array_int::end are overloaded, so you need to cast them to array_int::iterator (array_int::*)() to get the non-const versions.
auto gen = [] { return 0; };
using memfunc = array_int::iterator (array_int::*)();;
std::bind(std::generate<array_int::iterator, decltype(gen)>,
std::bind((memfunc)&array_int::begin, std::placeholders::_1),
std::bind((memfunc)&array_int::end, std::placeholders::_1),
gen));
You can make that a little bit simpler with generate_n since you know the size, and maybe using data() instead of begin(), although you still need to cast it:
auto gen = [] { return 0; };
using memfunc = int* (array_int::*)();;
std::bind(std::generate_n<int*, int, decltype(gen)>,
std::bind((memfunc)&array_int::data, std::placeholders::_1),
10,
gen));
Or you could just use a lambda:
std::for_each(vec.begin(), vec.end(), [](array_int& a) {
std::generate(a.begin(), a.end(), []{ return 0; });
});
If you want to call boost::generate instead it's a bit easier as you don't need a nested bind expression, but you still need the type of the generator:
auto gen = [] { return 0; };
std::bind(boost::generate<array_int, decltype(gen)>,
std::placeholders::_1
gen);
Or with a lambda:
std::for_each(vec.begin(), vec.end(), [](array_int& a) {
boost::generate(a, []{ return 0; });
});