Need to Total Fields From a Container of structs

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)(); }