Using an object's member function as the action passed to for_each

[Belebele]

Suppose I want to use some object's member function as the action
passed to a for_each call:

class A {
...
public:
void foo(int );
};

A a;
int ints[5];
....
for_each(0, 5, /*i want to call a.foo for each element in the range*/);




What is a good elegant way to do that?

What I did was to wrap the a object into a unary_function-derived
object and then pass the unary_function to the for_each method.

Any other ideas?

Thanks

 

[Thomas J. Gritzan]

Suppose I want to use some object's member function as the action
passed to a for_each call:

class A {
...
public:
void foo(int );
};

A a;
int ints[5];
...
for_each(0, 5, /*i want to call a.foo for each element in the range*/);

What is a good elegant way to do that?

#include <algorithm>
#include <boost/bind.hpp>

class A {
public:
void foo(int i) { };
};

int main()
{
A a;

int ints[5] = { 1, 2, 3, 4, 5};

std::for_each(ints, ints+5, boost::bind(&A::foo, a, _1));
}

There may be a way using std::bind* functions.

 

[Pierre Barbier de Reuille]

Suppose I want to use some object's member function as the action
passed to a for_each call:

class A {
...
public:
void foo(int );
};

A a;
int ints[5];
...
for_each(0, 5, /*i want to call a.foo for each element in the range*/);




What is a good elegant way to do that?

What I did was to wrap the a object into a unary_function-derived
object and then pass the unary_function to the for_each method.

Any other ideas?

Thanks

The best is to use std::mem_fun ... it already does what you want !
However, you need to combine it with std::bind1st like that :

for_each(0, 5, std::bind1st(std::mem_fun(A::foo), a));

Another option is to use the boost::bind library, in which case it would
look like:

for_each(0, 5, bind(A::foo, a, _1));

Pierre

 

[Victor Bazarov]

Suppose I want to use some object's member function as the action
passed to a for_each call:

class A {
...
public:
void foo(int );
};

A a;
int ints[5];
...
for_each(0, 5, /*i want to call a.foo for each element in the
range*/);

What is a good elegant way to do that?

#include <algorithm>
#include <boost/bind.hpp>

class A {
public:
void foo(int i) { };
};

int main()
{
A a;

int ints[5] = { 1, 2, 3, 4, 5};

std::for_each(ints, ints+5, boost::bind(&A::foo, a, _1));
}

There may be a way using std::bind* functions.

std::for_each(ints, ints+5,
std::bind1st(std::mem_fun1(&A::foo), &a));

(include <functional> instead of <boost..>)

V

 

[Victor Bazarov]

[..]
The best is to use std::mem_fun ... it already does what you want !
However, you need to combine it with std::bind1st like that :

for_each(0, 5, std::bind1st(std::mem_fun(A::foo), a));

Try it before recommending it. It won't work. Binders are tricky.

[..]

V

 

[Belebele]

class A {
...
public:
void foo(int );
};

The best is to use std::mem_fun ... it already does what you want !
However, you need to combine it with std::bind1st like that :

for_each(0, 5, std::bind1st(std::mem_fun(A::foo), a));

So, bind1st correctly binds the implicit "this" parameter ... I was
simply confused about that point.

Thanks!

 

[Pierre Barbier de Reuille]

So, bind1st correctly binds the implicit "this" parameter ... I was
simply confused about that point.

Thanks!

bind1st doesn't do anything like that. It just binds the first argument
of the function. It is std::mem_fun that convert a member function into
an object whose first argument is the object needed for the member
function. Also, as suggested higher, the for_each won't work like that,
you need an iterator (sorry, I copied that a bit quickly), so it should be:

int ints[6] = {0,1,2,3,4,5};
for_each(ints, ints+6, std::bind1st(std::mem_fun(&A::foo), &a));

(I also forgot the references ...)

Pierre