Need to Total Fields From a Container of structs - c++

Question

This is more of a code clenliness question, cause I already have an example here. I'm doing this a ton in code and the creation of all these lambdas (some of which are the same) has begun to irk me.
So given the struct:
struct foo {
int b() const { return _b; }
int a() const { return _a; }
int r() const { return _r; }
const int _b;
const int _a;
const int _r;
};
I have a container of pointers to them, let's say vector<foo*> foos, now I want to go through the container and get the sum of one of the fields.
As an example if I wanted the field _r, then my current approach is to do this:
accumulate(cbegin(foos), cend(foos), 0, [](const auto init, const auto i) { return init + i->r(); } )
I'm writing this line everywhere. Can any improvement be made upon this? I'd really like to write something like this:
x(cbegin(foos), cend(foos), mem_fn(&foo::r));
I don't think the standard provides anything like that. I could obviously write it, but then it would require the reader to go figure out my suspect code instead of just knowing what accumulate does.

Answer 1

Instead of writing a custom accumulate, I suggest writing a custom functor generator, that returns a functor that can be used as an argument to std::accumulate.
template<class Fun>
auto mem_accumulator(Fun member_function) {
return [=](auto init, auto i) {
return init + (i->*member_function)();
};
}
then
accumulate(cbegin(foos), cend(foos), 0, mem_accumulator(&foo::r));
A few variations:
For containers of objects:
template<class MemFun>
auto mem_accumulator(MemFun member_function) {
return [=](auto init, auto i) {
return init + (i.*member_function)();
};
}
Use data member pointers instead of functions:
template<class T>
auto mem_accumulator(T member_ptr) {
return [=](auto init, auto i) {
return init + i->*member_ptr;
};
}
// ...
accumulator(&foo::_r)
Support functors, rather than member function pointers:
template<class Fun>
auto accumulator(Fun fun) {
return [=](auto init, auto i) {
return init + fun(i);
};
}
// ...
accumulator(std::mem_fun(&foo::r))
Some (all?) of these variations could perhaps be combined to be selected automatically with some SFINAE magic, but that will increase complexity.

Answer 2

There is actually a really elegant way to solve this using Variable Templates which were introduced in c++14. We can templatize a lambda variable using the method pointer as the template argument:
template <int (foo::*T)()>
auto func = [](const auto init, const auto i){ return init + (i->*T)(); };
Passing the func appropriate specialization of func as the last argument to accumulate will have the same effect as writing out the lambda in place:
accumulate(cbegin(foos), cend(foos), 0, func<&foo::r>)
Live Example
Another alternative based off the same templatization premise, which does not require c++14, is the templatized function suggested by StoryTeller:
template <int (foo::*T)()>
int func(const int init, const foo* i) { return init + (i->*T)(); }
Which could also be used by simply passing the method pointer:
accumulate(cbegin(foos), cend(foos), 0, &func<&foo::r>)
Live Example
The specificity required by both these examples has been removed in c++17 where we can use auto for template parameter types: http://en.cppreference.com/w/cpp/language/auto This will allow us to declare func so it can be used by any class, not just foo:
template <auto T>
auto func(const auto init, const auto i) { return init + (i->*T)(); }