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?

I found a solution, courtesy of a set of tutorials for this that I somehow couldnt find before. The Function Pointer Tutorials - Syntax

First, sorry I put the main() inside the class body. Second, sorry I forgot to declare the members public. Third, for anyone curious to how I solved the issue, the compiler was right about * not being the same as newtest::*. So, I had to change the references to be of the "right type". That's basically all there was to it.

Code:

---

#include <iostream>
#include <string>

using namespace std;


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

        newtest::newtest(int (newtest::*functocall)(int,int))
        {
                int result = (*this.*functocall)(1,2);
                cout << result;
        }
};

int main ()
{
        cout << "First attempt: 1 + 2 = ";
        newtest thisTest(&newtest::addMe);

        cout << endl << "Second attempt: 3 + 4 = ";
        int (newtest::*reffunc)(int,int) = &newtest::addMe;
        int result = (thisTest.*reffunc)(3,4);
        cout << result;

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

---

Now my question is, is there a way to create a function pointer that can point to a member of any class?

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.