How can I create a pointer to a member function and call it?

How do I obtain a function pointer for a class member function, and later call that member function with a specific object?

It's easiest to start with a typedef. For a member function, you add the classname in the type declaration:

typedef void(Dog::*BarkFunction)(void); 

Then to invoke the method, you use the ->* operator:

(pDog->*pBark)(); 

Also, if possible, I’d like to invoke the constructor via a pointer as well. Is this possible, and if so, what is the preferred way to do this?

I don't believe you can work with constructors like this - ctors and dtors are special. The normal way to achieve that sort of thing would be using a factory method, which is basically just a static function that calls the constructor for you. See the code below for an example.

I have modified your code to do basically what you describe. There's some caveats below.

#include <iostream> class Animal { public: typedef Animal*(*NewAnimalFunction)(void); virtual void makeNoise() { std::cout << "M00f!" << std::endl; } }; class Dog : public Animal { public: typedef void(Dog::*BarkFunction)(void); typedef Dog*(*NewDogFunction)(void); Dog () {} static Dog* newDog() { return new Dog; } virtual void makeNoise () { std::cout << "Woof!" << std::endl; } }; int main(int argc, char* argv[]) { // Call member function via method pointer Dog* pDog = new Dog (); Dog::BarkFunction pBark = &Dog::makeNoise; (pDog->*pBark)(); // Construct instance via factory method Dog::NewDogFunction pNew = &Dog::newDog; Animal* pAnimal = (*pNew)(); pAnimal->makeNoise(); return 0; } 

Now although you can normally use a Dog* in the place of an Animal* thanks to the magic of polymorphism, the type of a function pointer does not follow the lookup rules of class hierarchy. So an Animal method pointer is not compatible with a Dog method pointer, in other words you can't assign a Dog* (*)() to a variable of type Animal* (*)().

The static newDog method is a simple example of a factory, which simply creates and returns new instances. Being a static function, it has a regular typedef (with no class qualifier).

Having answered the above, I do wonder if there's not a better way of achieving what you need. There's a few specific scenarios where you would do this sort of thing, but you might find there's other patterns that work better for your problem. If you describe in more general terms what you are trying to achieve, the hive-mind may prove even more useful!

Related to the above, you will no doubt find the Boost bind library and other related modules very useful.

I don't think anyone has explained here that one issue is that you need "member pointers" rather than normal function pointers.

Member pointers to functions are not simply function pointers. In implementation terms, the compiler cannot use a simple function address because, in general, you don't know the address to call until you know which object to dereference for (think virtual functions). You also need to know the object in order to provide the this implicit parameter, of course.

Having said that you need them, now I'll say that you really need to avoid them. Seriously, member pointers are a pain. It is much more sane to look at object-oriented design patterns that achieve the same goal, or to use a boost::function or whatever as mentioned above - assuming you get to make that choice, that is.

If you are supplying that function pointer to existing code, so you really need a simple function pointer, you should write a function as a static member of the class. A static member function doesn't understand this, so you'll need to pass the object in as an explicit parameter. There was once a not-that-unusual idiom along these lines for working with old C code that needs function pointers

class myclass { public: virtual void myrealmethod () = 0; static void myfunction (myclass *p); } void myclass::myfunction (myclass *p) { p->myrealmethod (); } 

Since myfunction is really just a normal function (scope issues aside), a function pointer can be found in the normal C way.

EDIT - this kind of method is called a "class method" or a "static member function". The main difference from a non-member function is that, if you reference it from outside the class, you must specify the scope using the :: scope resolution operator. For example, to get the function pointer, use &myclass::myfunction and to call it use myclass::myfunction (arg);.

This kind of thing is fairly common when using the old Win32 APIs, which were originally designed for C rather than C++. Of course in that case, the parameter is normally LPARAM or similar rather than a pointer, and some casting is needed.

Minimal runnable example

main.cpp

#include <cassert> class C { public: int i; C(int i) : i(i) {} int m(int j) { return this->i + j; } }; int main() { // Get a method pointer. int (C::*p)(int) = &C::m; // Create a test object. C c(1); C *cp = &c; // Operator .* assert((c.*p)(2) == 3); // Operator ->* assert((cp->*p)(2) == 3); } 

Compile and run:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp ./main.out 

Tested in Ubuntu 18.04.

You cannot change the order of the parenthesis or omit them. The following do not work:

c.*p(2) c.*(p)(2) 

GCC 9.2 would fail with:

main.cpp: In function ‘int main()’: main.cpp:19:18: error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘p (...)’, e.g. ‘(... ->* p) (...)’ 19 | assert(c.*p(2) == 3); | 

C++11 standard

.* and ->* are a single operators introduced in C++ for this purpose, and not present in C.

C++11 N3337 standard draft:

• 2.13 "Operators and punctuators" has a list of all operators, which contains .* and ->*.
• 5.5 "Pointer-to-member operators" explains what they do

typedef void (Dog::*memfun)(); memfun doSomething = &Dog::bark; .... (pDog->*doSomething)(); // if pDog is a pointer // (pDog.*doSomething)(); // if pDog is a reference 

I came here to learn how to create a function pointer (not a method pointer) from a method but none of the answers here provide a solution. Here is what I came up with:

template <class T> struct MethodHelper; template <class C, class Ret, class... Args> struct MethodHelper<Ret (C::*)(Args...)> { using T = Ret (C::*)(Args...); template <T m> static Ret call(C* object, Args... args) { return (object->*m)(args...); } }; #define METHOD_FP(m) MethodHelper<decltype(m)>::call<m> 

So for your example you would now do:

Dog dog; using BarkFunction = void (*)(Dog*); BarkFunction bark = METHOD_FP(&Dog::bark); (*bark)(&dog); // or simply bark(&dog) 

Edit:
Using C++17, there is an even better solution:

template <auto m> struct MethodHelper; template <class C, class Ret, class... Args, Ret (C::*m)(Args...)> struct MethodHelper<m> { static Ret call(C* object, Args... args) { return (object->*m)(args...); } }; 

which can be used directly without the macro:

Dog dog; using BarkFunction = void (*)(Dog*); BarkFunction bark = MethodHelper<&Dog::bark>::call; (*bark)(&dog); // or simply bark(&dog) 

For methods with modifiers like const you might need some more specializations like:

template <class C, class Ret, class... Args, Ret (C::*m)(Args...) const> struct MethodHelper<m> { static Ret call(const C* object, Args... args) { return (object->*m)(args...); } }; 

A function pointer to a class member is a problem that is really suited to using boost::function. Small example:

#include <boost/function.hpp> #include <iostream> class Dog { public: Dog (int i) : tmp(i) {} void bark () { std::cout << "woof: " << tmp << std::endl; } private: int tmp; }; int main() { Dog* pDog1 = new Dog (1); Dog* pDog2 = new Dog (2); //BarkFunction pBark = &Dog::bark; boost::function<void (Dog*)> f1 = &Dog::bark; f1(pDog1); f1(pDog2); } 

Reason why you cannot use function pointers to call member functions is that ordinary function pointers are usually just the memory address of the function.

To call a member function, you need to know two things:

• Which member function to call
• Which instance should be used (whose member function)

Ordinary function pointers cannot store both. C++ member function pointers are used to store a), which is why you need to specify the instance explicitly when calling a member function pointer.

To create a new object you can either use placement new, as mentioned above, or have your class implement a clone() method that creates a copy of the object. You can then call this clone method using a member function pointer as explained above to create new instances of the object. The advantage of clone is that sometimes you may be working with a pointer to a base class where you don't know the type of the object. In this case a clone() method can be easier to use. Also, clone() will let you copy the state of the object if that is what you want.

I did this with std::function and std::bind..

I wrote this EventManager class that stores a vector of handlers in an unordered_map that maps event types (which are just const unsigned int, I have a big namespace-scoped enum of them) to a vector of handlers for that event type.

In my EventManagerTests class, I set up an event handler, like this:

auto delegate = std::bind(&EventManagerTests::OnKeyDown, this, std::placeholders::_1); event_manager.AddEventListener(kEventKeyDown, delegate); 

Here's the AddEventListener function:

std::vector<EventHandler>::iterator EventManager::AddEventListener(EventType _event_type, EventHandler _handler) { if (listeners_.count(_event_type) == 0) { listeners_.emplace(_event_type, new std::vector<EventHandler>()); } std::vector<EventHandler>::iterator it = listeners_[_event_type]->end(); listeners_[_event_type]->push_back(_handler); return it; } 

Here's the EventHandler type definition:

typedef std::function<void(Event *)> EventHandler; 

Then back in EventManagerTests::RaiseEvent, I do this:

Engine::KeyDownEvent event(39); event_manager.RaiseEvent(1, (Engine::Event*) & event); 

Here's the code for EventManager::RaiseEvent:

void EventManager::RaiseEvent(EventType _event_type, Event * _event) { if (listeners_.count(_event_type) > 0) { std::vector<EventHandler> * vec = listeners_[_event_type]; std::for_each( begin(*vec), end(*vec), [_event](EventHandler handler) mutable { (handler)(_event); } ); } } 

This works. I get the call in EventManagerTests::OnKeyDown. I have to delete the vectors come clean up time, but once I do that there are no leaks. Raising an event takes about 5 microseconds on my computer, which is circa 2008. Not exactly super fast, but. Fair enough as long as I know that and I don't use it in ultra hot code.

I'd like to speed it up by rolling my own std::function and std::bind, and maybe using an array of arrays rather than an unordered_map of vectors, but I haven't quite figured out how to store a member function pointer and call it from code that knows nothing about the class being called. Eyelash's answer looks Very Interesting..

As a workaround/trick if you have control over the C API you could normally put a void* extra argument inside the C callback signature, afterward you will cast it (reinterpret_cast) to what you would expect.