How to pass method of a class into another function in C++? - c++

Question

Say I have a class and a function
class A
{
int a;
int b;
int mul()
{
return a+b;
}
};
...
void func(int af, int bf, int (*fc)())
{
...
}
In the main function, the function is supposed to use the methods of class A
int main
{
A as;
...
func(as.a, as.b, as.mul);
}
However, I can't do that, the compiler keeps telling me that I'm passing
(int&, int&, 'unresolved overloaded function type')
into a function of candidate
(int, int, void(*)()).
Why is that, and how to pass method of a class into another function?
Oh, I think I should make the problem a little bit clearer. func(...) is actually a function from an algorithm I'm working on. And class A is a model that will use the algorithm to do the simulation. So I don't think I'll specifically use the instance of A in function B, but only pass A's methods and components in and work with them.
Update: Some have mentioned using static methods in class A. However, this is still a partial solution. Using static method mul() will force me to claim a and b both to be static. And if I have to use multiple instances of A, with method a, b different in each instance in my main function, using static variables will simply fail.
So, are there other suggestions on how to fix this without using static variables/methods? I remember in script languages such as python, passing methods of whatever type is basically not an issue. Why can't I do a similar thing in C++? Or are there workarounds in C++ that can help me do this?

Answer 1

First of all, mul is a member function of A, so you can't invoke it as if it was a global function or a static member function: it needs an object on which the function is invoked:
A::mul(); // ERROR!
A a;
a.mul(); // OK
This said, you could change the definition of func to accept a pointer-to-member-function:
void func(int af, int bf, void (A::*fc)())
// ^^^^^^^^^^^^^^^
However, this change alone won't make you progress too much, because you're still not passing the concrete instance of A on which the member function should be invoked. In other words, this would be illegal:
fc(); // ERROR!
To over come this limitation, you could pass a reference or a pointer to an instance of A together to func, and call it as done below:
void func(A* pA, int af, int bf, void (A::*fc)())
{
...
(pA->*func)();
}
However, if func() has the object on which the member function should be invoked passed in as an argument, it is not clear what is the purpose of af and bf.
Possibly, if your mul() member function does not need to work on any concrete instance of A, and still you want to make it a member of A, you could declare it as static:
class A
{
int a;
int b;
static void mul();
// ^^^^^^
};
This would make your original call to func() compile. However, in this case it is not clear whether this would make sense, since the fact that mul() accept no arguments suggests that it is supposed to work on the a and b members of the object it is invoked on.

Answer 2

Is mul indended to be a non-static member, needing an object of type A to invoke it on? In that case, you'll need to pass a pointer-to-member:
void func(int af, int bf, void (A::*fc)())
{ // ^^^
A a = whatever();
(a.*fc)();
}
If it's intended to be called without an object, then it needs to be static.

Answer 3

What you want to do is to pass a member function pointer (A::mul) along with the instance (a) itself. That's not that easy without any additional code.
Member function pointers aren't tied to an instance (they only represent the function itself, not the instance on which to be called on). Their type is described together with the class name. The type of a member function pointer on A with the signature of your func will look like this:
void (A::*)() // The type only, anonymous
void (A::*fc)() // An actual function pointer with the name `fc`
To call such a function, you have to use the following syntax, in which, as you can see, the instance to call the function on, has to be involved:
(a->*fc)(); // If a is of type A*
(a.*fc)(); // If a is of type A or A&
To put things together, you have basically two options.
Also pass the instance (as a pointer, a reference, either const or modifiable) in addition to a member function pointer. Then, call the member function pointer on that instance.
You're function's signature and implementation will then look like this:
void func(int af, int bf, void (A::*fc)(), A *a) {
// When you want to call the function fc on a:
(a->*fc)();
}
To call func, use a code like this:
func(as.a, as.b, &A::mul, a);
Convert the member function pointer together with the instance to a functor which can be called as is. This can be best done with std::mem_fn together with std::bind1st.
You're function's signature and implementation will then look like this:
void func(int af, int bf, std::function<void()> fc) {
// When you want to call the function fc:
fc();
}
To call func, use a code like this:
func(as.a, as.b, std::bind1st(std::mem_fn(&A::mul), a));

Answer 4

If you really want to treat int (*fc)(int,int) (void return and empty parameter list given in another example) as a regular function pointer (I mean not function pointer to class member function), You can do the following to use the function of A and pass it into func. The point is to declare mul as static member function. I am assuming very simple operation like multiplication.
#include <iostream>
class A
{
public: //necessary otherwise not accessible in main
int a;
int b;
A(int p1, int p2):a(p1),b(p2){} //assume you need to somehow pass a,b into mul
static int mul(int p1, int p2) {return p1*p2;}; //mul should be static
};
void func(int af, int bf, int (*fc)(int,int))
//using void still work but you need to change declaration of mul in A
{
int res = fc(af,bf);
cout << res <<endl;
}
int main()
{
A as(2,4);
func(as.a, as.b, &A::mul); //call A::mul, use as regular function pointer, output 8
func(10,10, &A::mul); //will output 100
return 0;
}
This way you are using the static member function of A that can be pointed to by a regular function pointer. It has nothing to do as a and b inside the class anymore.

Answer 5

As leemes said, you can do this with std::function which is what I would recommend as well, but check out what your compiler has support for, and if so, you can use a single call to std::bind and have it work. Example below that works on Visual Studio 2012 (and should work on newer versions of GCC with the flag for C++11 enabled, and may or may not work on VS 2010)
void func(int af, int bf, std::function<void()> fc)
{
fc();
}
call with:
func(as.a, as.b, std::bind(&as::mul, &A));
The newer versions of std::bind do the std::mem_fcn part for you if it detects a member function. See the doc linked here:
std::function
std::bind