I have a vector of vectors or some nested data structure of that sort. I
want to loop over the outer structure and summarize the inner structure,
like taking averages of all the vectors or what not. Once I saw that in the
code three times I thought it was time to abstract it out. So the plan was
to have a generic loop function that takes a functor type for the action to
perform inside the loop. So far so good. In many instances that action is a
standard algorithm or composition thereof, so why not use functors like
those returned by bind(accumulate, _1, _2, 0) instead of writing little
polluting classes like BinFunc below? But the compiler is at a loss guessing
the types, and it looks to me like it is for a good reason, because to
instantiate the accumulate template it has to know the precise signature of
my loop function and the converse too. Can the lambda experts shed light on
this? It seems a quite natural use case. Thanks
Antonio
PS: in an ideal world the following example can be done combining transform
call_begin and call_end, but that an whole different story
#include
#include
#include <vector>
#include <numeric>
#include <functional>
using namespace boost::lambda;
template
void loop_func(NestedIt start, NestedIt stop, It dest, Func f) {
for(;start < stop; start++, dest++) {
*dest = f(start->begin(), start->end());
}
}
class BinFunc:
public std::binary_function {
public:
int operator()
(std::vector<int>::iterator b,
std::vector<int>::iterator e) {
return accumulate(b,e,0);
}
};
int main() {
std::vector<int> d;
std::vector s;
loop_func(s.begin(), s.end (), d.begin(),
BinFunc()); //flies with gcc
loop_func(s.begin(), s.end(), d.begin(),
bind<int>(std::accumulate, _1, _2, 0.0)); //does not
}
bind_test.cpp: In function 'int main()':
bind_test.cpp:32: error: invalid initialization of reference of type 'const
int&' from expression of type '<unknown type>'
/usr/include/boost/lambda/detail/bind_functions.hpp:532: error: in passing
argument 1 of 'const
boost::lambda::lambda_functor >,
typename boost::lambda::detail::bind_tuple_mapper::type> >
boost::lambda::bind(const Arg1&, const Arg2&, const Arg3&, const Arg4&)
[with Arg1 = int, Arg2 =
boost::lambda::lambda_functor >, Arg3 =
boost::lambda::lambda_functor >, Arg4 =
double]'
