Thread: Pointers to functions problem

Solved. Related question: Is there a way to create a function pointer that can point to a member of any class?

Can someone share with me the correct way to use a function belonging to another class through function pointers? Neither of these seem to work:

Code:

#include <iostream>
#include <string>

using namespace std;

class newtest
{
	int newtest::addMe(int a, int b)
	{
		return a + b;
	}

	newtest::newtest(int (*functocall)(int,int))
	{
		int result = (*functocall)(1,2);
		cout << result;
	}
	
	int main ()
	{
		cout << "First attempt: 1 + 2 = ";
		newtest thisTest(newtest::addMe);   // Error here

		cout << endl << "Second attempt: 3 + 4 = ";
		int (*reffunc)(int,int) = newtest::addMe;   // Error here
		int result = (*reffunc)(3,4);
		cout << result;

		string dontcare;
		cin >> dontcare;
		return 0;
	}
};

I've tried with and without the newtest:: preceeding the function name. This will not compile in VC++ 2010. The compile error is not very helpful. "error C3867: 'newtest::addMe': function call missing argument list; use '&newtest::addMe' to create a pointer to member" for both lines. When I add the &, it just changes the error message to an illegal operator one.

The mouseover messages are a little more descriptive. The first line gives "no instance of constructor 'newtest::newtest' matches the argument list". The second line "a value of type 'int (newtest::*)(int a, int b)' cannot be used to initialize an entity of type 'int (*)(int,int)'".

What do you guys think?

OK, to be honest, you also forgot that, unlike normal function pointers, you must use a & on the function to get the address. An oversight in the original standard, yet now fixed for member functions.
Also, note that when calling a member function, you need to specify the member function of whose instance you want to call.

Using
(*this.*functocall)(1,2);
is pretty pointless.
You would probably want something like
(instance.*function_to_call)(1, 2);
Where instance is a (const) newtest&.

However, for all of that, there is much simpler way (and more practical) to accept a function pointer. You simply accept a template:
template<typename T>
newtest::newtest(T function_to_call)

Then,
function_to_call(1, 2);
will always work so long as what you pass in supports the operator () syntax, may that be a function pointer, member function pointer, lambda or just some custom functor.
There is also std::function for dynamically binding a function object like described above. It has a slight overhead, though, so these two methods complement each other.