Calling C class methods via a function pointer

Question

How do I obtain a function pointer for a class member function  and later call that member function with a specific object   I   d like to write   class Dog   Animal       Dog         void bark            Dog  pDog   new Dog     BarkFunction pBark    amp Dog  bark    pBark   pDog         Also  if possible  I   d like to invoke the constructor via a pointer as well   NewAnimalFunction pNew    amp Dog  Dog  Animal  pAnimal     pNew           Is this possible  and if so  what is the preferred way to do this

User · Answer

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.

User · Answer

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- gt 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  amp 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

User · Answer

A function pointer to a class member is a problem that is really suited to using boost  function  Small example    include  lt boost function hpp gt   include  lt iostream gt   class Dog    public     Dog  int i    tmp i        void bark               std  cout  lt  lt   woof     lt  lt  tmp  lt  lt  std  endl       private     int tmp        int main        Dog  pDog1   new Dog  1      Dog  pDog2   new Dog  2         BarkFunction pBark    amp Dog  bark     boost  function lt void  Dog   gt  f1    amp Dog  bark      f1 pDog1      f1 pDog2

User · Answer

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  amp EventManagerTests  OnKeyDown  this  std  placeholders   1   event manager AddEventListener kEventKeyDown  delegate    Here s the AddEventListener function  std  vector lt EventHandler gt   iterator EventManager  AddEventListener EventType  event type  EventHandler  handler        if  listeners  count  event type     0                 listeners  emplace  event type  new std  vector lt EventHandler gt                std  vector lt EventHandler gt   iterator it   listeners   event type - gt end        listeners   event type - gt push back  handler              return it     Here s the EventHandler type definition  typedef std  function lt void Event    gt  EventHandler   Then back in EventManagerTests  RaiseEvent  I do this  Engine  KeyDownEvent event 39   event manager RaiseEvent 1   Engine  Event    amp  event    Here s the code for EventManager  RaiseEvent  void EventManager  RaiseEvent EventType  event type  Event    event        if  listeners  count  event type   gt  0                std  vector lt EventHandler gt    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

User · Answer

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

User · Answer

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  lt class T gt  struct MethodHelper  template  lt class C  class Ret  class    Args gt  struct MethodHelper lt Ret  C     Args     gt        using T   Ret  C     Args          template  lt T m gt  static Ret call C  object  Args    args            return  object- gt  m  args                 define METHOD FP m  MethodHelper lt decltype m  gt   call lt m gt    So for your example you would now do   Dog dog  using BarkFunction   void     Dog    BarkFunction bark   METHOD FP  amp Dog  bark     bark   amp dog      or simply bark  amp dog    Edit  Using C  17  there is an even better solution   template  lt auto m gt  struct MethodHelper  template  lt class C  class Ret  class    Args  Ret  C   m  Args     gt  struct MethodHelper lt m gt        static Ret call C  object  Args    args            return  object- gt  m  args                 which can be used directly without the macro   Dog dog  using BarkFunction   void     Dog    BarkFunction bark   MethodHelper lt  amp Dog  bark gt   call    bark   amp dog      or simply bark  amp dog    For methods with modifiers like const you might need some more specializations like   template  lt class C  class Ret  class    Args  Ret  C   m  Args     const gt  struct MethodHelper lt m gt        static Ret call const C  object  Args    args            return  object- gt  m  args

User · Answer

typedef void  Dog   memfun     memfun doSomething    amp Dog  bark        pDog- gt  doSomething        if pDog is a pointer     pDog  doSomething        if pDog is a reference

User · Answer

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

User · Answer

Minimal runnable example  main cpp   include  lt cassert gt   class C       public          int i          C int i    i i             int m int j    return this- gt i   j        int main            Get a method pointer      int  C   p  int     amp C  m          Create a test object      C c 1       C  cp    amp c          Operator        assert  c  p  2     3           Operator - gt       assert  cp- gt  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    - gt      to call pointer-to-member function in    p           e g          - gt   p              19       assert c  p 2     3             C  11 standard     and - gt   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 - gt    5 5  Pointer-to-member operators  explains what they do

User · Answer

Read this for detail       1 define a function pointer and initialize to NULL  int  TMyClass   pt2ConstMember  float  char  char  const   NULL      C    class TMyClass   public     int DoIt float a  char b  char c   cout  lt  lt   TMyClass  DoIt  lt  lt  endl  return a b c       int DoMore float a  char b  char c  const            cout  lt  lt   TMyClass  DoMore   lt  lt  endl  return a-b c            more of TMyClass       pt2ConstMember    amp TMyClass  DoIt     note   lt pt2Member gt  may also legally point to  amp DoMore     Calling Function using Function Pointer    this  pt2ConstMember  12   a    b

[c++] Calling C++ class methods via a function pointer

Examples related to c++

Examples related to function-pointers

Examples related to class-method