I don't know about you, but the C++ syntax for member function pointers always eludes me.  Every time I would spend half an hour or more deciphering MSDN to get the exact syntax, only to completely forget it the next time.  Oops.

I can think of three reasons why this is happening:

1. The C++ syntax sucks;
2. I'm getting old; and
3. The existing documentation sucks.

While I cannot do much about the first two, I figure at least I can work on the third.  The result is this quick reference.  It has helped me in a number of situations.  It might help you as well, if you are getting old too!

You use a member function pointer because eventually you want to invoke it.  Before you can do that, you also need to declare the type of the pointer, define a variable of that type, and assign a value to that variable.  This reference teaches you how to do each of them.

• Declaring a member function pointer type

Suppose you want to point to a non-static member function of a class CMyClass, where the argument has type Arg and the result type is Res.  You can declare the type of your pointer by

typedef Res (CMyClass::*MemFunc)( Arg );

(Note the highlighted parentheses cannot be omitted).

Then you can declare your member function pointer pMemFunc as having type MemFunc:

MemFunc pMemFunc;

• Obtaining a value of your member function pointer type

The next step, you need to give a value to your pointer.  Suppose the CMyClass class looks like:

class CMyClass

{

...

Res MyMethod( Arg arg );

...

};

You can let pMemFunc points to the function MyMethod by:

pMemFunc = &CMyClass::MyMethod;

Alternatively, you can do without the ampersand, which is my preferred way:

pMemFunc = CMyClass::MyMethod;

• Invoking a member function via a member function pointer

Now that your pointer has a value, it's time to put it to use!  Since pMemFunc points to a member function, you need to have an object to begin with.  Suppose the object is called MyObj:

CMyClass MyObj;

You can invoke the function pointed to by pMemFunc on MyObj like this:

Res result = (MyObj.*pMemFunc)( arg );

Note that the highlighted parentheses cannot be omitted.

However, none of the following syntaxes is accepted:

Res result = MyObj.(*pMemFunc)( arg );

// Won't compile

Res result = MyObj.*pMemFunc( arg );

// Won't compile either

Res result = MyObj.pMemFunc( arg );

// You wish!

This is different from how C++ treats member functions (you can write either (MyObj.MyMethod)( arg ) or MyObj.MyMethod( arg )), and different from how it treats ordinary (non-member) function pointers too (given a function pointer pFunc, you can invoke it with either (*pFunc)( arg ) or pFunc( arg )).

In an ideal language, all constructs should be equal (to be precise, I mean "orthogonal").  Now C++ is telling me that member function pointers are less equal than others.  This bothers me.  This bothers me tremendously.

Maybe C++ has become old?