Call member function on each element in a container.

Question

Hello,

This question is a matter of style, since you can always write a for loop or something similar; however, is there a less obtrusive STL or BOOST equivalent to writing:

for (container<type>::iterator iter = cointainer.begin();
     iter != cointainer.end();
     iter++)
 iter->func();

?

Something like (imagined) this:

call_for_each(container.begin(), container.end(), &Type::func);

I think it would be 1) less typing, 2) easier to read, 3) less changes if you decided to change base type/container type.

EDIT: Thanks for your help, now, what if I wanted to pass some arguments to the member function?

Answer 1

 #include <algorithm> // for_each
 #include <functional> // mem_fun

 // ...

 std::for_each(container.begin(), container.end(), 
                   std::mem_fun(&Type::func));

See for_each and mem_fun documentation for details.

Missed your edit: Anyway here is another way of achieving what you want without using Boost, if ever need be:

std::for_each(foo_vector.begin(), foo_vector.end(),
    std::bind2nd(std::mem_fun_ref(&Foo::func), 1));

Answer 2

You can use std::for_each or boost's foreach constructs.

Use boost's BOOST_FOREACH or BOOST_REVERSE_FOREACH when you don't want to move the logic into another function.

Answer 3

If you actually want to improve performance rather than just pretty up your code, what you really need is a map function. Eric Sink wrote a .net implementation

Answer 4

I found out that boost bind seems to be well suited for the task, plus you can pass additional arguments to the method:

#include <iostream>
#include <functional>
#include <boost/bind.hpp>
#include <vector>
#include <algorithm>

struct Foo {
    Foo(int value) : value_(value) {
    }

    void func(int value) {
        std::cout << "member = " << value_ << " argument = " << value << std::endl;
    }

private:
    int value_;
};

int main() {
    std::vector<Foo> foo_vector;

    for (int i = 0; i < 5; i++)
        foo_vector.push_back(Foo(i));

    std::for_each(foo_vector.begin(), foo_vector.end(),
        boost::bind(&Foo::func, _1, 1));
}