passing member functions as parameters / c++

Question

I would like to implement, in c++, a class b where it would be possible to do some kind of iteration through a member set encapsulating the type of that iterator. Like:

b_object.for_each_x_do(function_f);

so function_f would get everyone of the x members and do anything. Let's say:

void function_f(x_member_type x){ cout << x << endl; }

Ok. So I'm trying to achieve that through a code like:

class b{
    int *x;
public:
    void foreach_x_do(void (*f)(int)){
            while(*x++)  // or any kind of iteration through x
                    f(*x);
    }
};

class a{
    b b_inst;
public:
    void f(int x) {  }     
    a(){
            b_inst.foreach_x_do(f); // by mistake it was b_inst.foreach_x_do(f)(), however this wasn't the point at all. 
    }
    ~a(){}
};

int main(){}

However, I'm getting this error, compile-time:

fp.cpp: In constructor ‘a::a()’:
fp.cpp:17: error: no matching function for call to ‘b::foreach_x_do(<unresolved overloaded function type>)’
fp.cpp:6: note: candidates are: void b::foreach_x_do(void (*)(int))

Anybody can help getting it to compile?

For one thing, the f you are passing to foreach_x_do is not a void(*)(int) it is a void (a::*)(int). — steveo225
– steveo225, Commented May 19, 2011 at 18:26
Just a sidenote, you should probably name your classes with uppercase. So class B instead of class b. Just to conform to common ussage. — Falmarri
– Falmarri, Commented May 19, 2011 at 18:29
This FAQ will give you more information than you want to know about passing member functions. — jedwards
– jedwards, Commented May 19, 2011 at 18:37

ildjarn · Accepted Answer · 2011-05-19 18:34:17Z

As @steveo225 noted, f in that context is of type void (a::*)(int) rather than void (*)(int). There are two approaches to fixing this -- the first is to make b::foreach_x_do a member function template that takes any callable type:

class b {
    int* x;

public:
    b() : x() { }
    template<typename F>
    void foreach_x_do(F f) {
        while(*x++)
            f(*x);
    }
};

class a {
    b b_inst;

public:
    void f(int x) { }
    a() : b_inst() {
        b_inst.foreach_x_do(std::bind(&a::f, this, _1));
    }
};

The second is to keep b::foreach_x_do a non-template and have it take a std::function<> instead of a function pointer:

class b {
    int* x;

public:
    b() : x() { }
    void foreach_x_do(std::function<void(int)> const& f) {
        while(*x++)
            f(*x);
    }
};

class a {
    b b_inst;

public:
    void f(int x) { }
    a() : b_inst() {
        b_inst.foreach_x_do(std::bind(&a::f, this, _1));
    }
};

In either case, replace std::bind and std::function with their boost:: counterparts if your compiler is too old to ship with std:: or std::tr1:: implementations. Also note that if you have a C++11 compiler, you can use a lambda instead of bind.

Jason · Accepted Answer · 2011-05-19 18:31:37Z

1

It should just be:

b_inst.foreach_x_do(f);

You also need to make f static, not a non-static member method since the original signature for your foreach_x_do function is for a stand-alone function pointer, not a pointer-to-member-function. So i.e.,

static void f(int x) {  }

edited May 19, 2011 at 18:31

answered May 19, 2011 at 18:26

Jason

32.7k8 gold badges63 silver badges81 bronze badges

2 Comments

ribamar Over a year ago

i don't know if there any traps with this solution (since the method becomes static) but for my simple task it works good. Maybe the solutions using bind() are better, but I liked this one because it is more compiler-independent.

Jason Over a year ago

The main "trap" is that the static function cannot directly access a non-static member or method of the class ... so if you need to access a non-static data-member or method, you'll have to pass a reference or pointer to the class-object as an argument to the function.

Pablo · Accepted Answer · 2011-05-19 18:32:51Z

1

The function for_each_x_do is expecting a function pointer, while you're (trying) to give it a member function pointer. The two are not the same. The former can be called directly, while the latter requires an object instance to be called. I'd suggest you use std::function or boost::function instead. Something like:

void for_each_x_do(function<void (int)> f) {
  // your code here
}

And then use a binder to construct a function object:

a(){
  b_inst.foreach_x_do(bind(&a::f, this, _1));     
}

answered May 19, 2011 at 18:32

Pablo

8,6742 gold badges41 silver badges29 bronze badges

Comments

slartibartfast · Accepted Answer · 2011-05-19 18:26:24Z

0

In this line:

 b_inst.foreach_x_do(f)();

Remove the second set of parenthesis; you don't need them.

 b_inst.foreach_x_do(f);

should work fine.

answered May 19, 2011 at 18:26

slartibartfast

4,4665 gold badges35 silver badges48 bronze badges

Comments

jedwards · Accepted Answer · 2011-05-19 18:35:04Z

0

f() is a member function -- so it's relevance is limited to it's corresponding object. Some of these solutions so far won't work.

You have two choices, either make the function static, in which case it doesn't matter which object, or somehow also pass the object.

The second method is clearly explained in this helpful FAQ specifically about passing member functions.

answered May 19, 2011 at 18:35

jedwards

30.3k3 gold badges69 silver badges94 bronze badges

Comments

Localghost · Accepted Answer · 2011-05-19 18:29:15Z

-2

Try:

class b{
int *x;
public:
void foreach_x_do(void (*f)(int)){
        while(*x++)  // or any kind of iteration through x
                (*f)(*x);
}

};

answered May 19, 2011 at 18:29

Localghost

7203 silver badges7 bronze badges

Collectives™ on Stack Overflow

passing member functions as parameters / c++

6 Answers 6

Comments

2 Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

2 Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related