C callback using class member

Question

I know this has been asked so many times  and because of that it s difficult to dig through the cruft and find a simple example of what works   I ve got this  it s simple and it works for MyClass      include  lt iostream gt  using std  cout  using std  endl   class MyClass       public          MyClass            static void Callback MyClass  instance  int x       private          int private x      class EventHandler       public          void addHandler MyClass  owner                        cout  lt  lt   Handler added      lt  lt  endl                Let s pretend an event just occured             owner- gt Callback owner 1                 EventHandler  handler   MyClass  MyClass         private x   5      handler- gt addHandler this      void MyClass  Callback MyClass  instance  int x        cout  lt  lt  x   instance- gt private x  lt  lt  endl     int main int argc  char   argv        handler   new EventHandler        MyClass  myClass   new MyClass       class YourClass       public          YourClass            static void Callback YourClass  instance  int x        How can that be rewritten so EventHandler  addHandler   will work with both MyClass and YourClass  I m sorry but it s just the way my brain works  I need to see a simple example of what works before I can comprehend why how it works  If you ve got a favorite way to make this work now s the time to show it off  please markup that code and post it back    edit   It was answered but the answer was deleted before I could give the checkmark  The answer in my case was a templated function  Changed addHandler to this     class EventHandler       public          template lt typename T gt          void addHandler T  owner                        cout  lt  lt   Handler added      lt  lt  endl                Let s pretend an event just occured             owner- gt Callback owner 1

User · Answer

What you want to do is to make an interface which handles this code and all your classes implement the interface.

class IEventListener{
public:
   void OnEvent(int x) = 0;  // renamed Callback to OnEvent removed the instance, you can add it back if you want.
};


class MyClass :public IEventListener
{
    ...
    void OnEvent(int x); //typically such a function is NOT static. This wont work if it is static.
};

class YourClass :public IEventListener
{

Note that for this to work the "Callback" function is non static which i believe is an improvement. If you want it to be static, you need to do it as JaredC suggests with templates.

User · Answer

Here s a concise version that works with class method callbacks and with regular function callbacks  In this example  to show how parameters are handled  the callback function takes two parameters  bool and int   class Caller     template lt class T gt  void addCallback T  const object  void T    const mf  bool int           using namespace std  placeholders       callbacks  emplace back std  bind mf  object   1   2          void addCallback void   const fun  bool int            callbacks  emplace back fun         void callCallbacks bool firstval  int secondval           for  const auto amp  cb   callbacks         cb firstval  secondval       private    std  vector lt std  function lt void bool int  gt  gt  callbacks      class Callee     void MyFunction bool int        then  somewhere in Callee  to add the callback  given a pointer to Caller  ptr   ptr- gt addCallback this   amp Callee  MyFunction      or to add a call back to a regular function ptr- gt addCallback  amp MyRegularFunction     This restricts the C  11-specific code to the addCallback method and private data in class Caller  To me  at least  this minimizes the chance of making mistakes when implementing it

User · Answer

Instead of having static methods and passing around a pointer to the class instance  you could use functionality in the new C  11 standard  std  function and std  bind    include  lt functional gt  class EventHandler       public          void addHandler std  function lt void int  gt  callback                        cout  lt  lt   Handler added      lt  lt  endl                 Let s pretend an event just occured             callback 1                  The addHandler method now accepts a std  function argument  and this  function object  have no return value and takes an integer as argument   To bind it to a specific function  you use std  bind   class MyClass       public          MyClass                Note  No longer marked  static   and only takes the actual argument         void Callback int x       private          int private x      MyClass  MyClass         using namespace std  placeholders     for   1       private x   5      handler- gt addHandler std  bind  amp MyClass  Callback  this   1       void MyClass  Callback int x           No longer needs an explicit  instance  argument         as  this  is set up properly     cout  lt  lt  x   private x  lt  lt  endl      You need to use std  bind when adding the handler  as you explicitly needs to specify the otherwise implicit this pointer as an argument  If you have a free-standing function  you don t have to use std  bind   void freeStandingCallback int x                  int main                    handler- gt addHandler freeStandingCallback       Having the event handler use std  function objects  also makes it possible to use the new C  11 lambda functions   handler- gt addHandler    int x    std  cout  lt  lt   x is    lt  lt  x  lt  lt    n

User · Answer

If you have callbacks with different parameters you can use templates as follows     compile with  g   -std c  11 myTemplatedCPPcallbacks cpp -o myTemplatedCPPcallbacksApp    include  lt functional gt         c  11   include  lt iostream gt            due to  cout   using std  cout  using std  endl   class MyClass       public          MyClass            static void Callback MyClass  instance  int x       private          int private x      class OtherClass       public          OtherClass            static void Callback OtherClass  instance  std  string str       private          std  string private str      class EventHandler        public          template lt typename T  class T2 gt          void addHandler T  owner  T2 arg2                        cout  lt  lt    nHandler added      lt  lt  endl                Let s pretend an event just occured             owner- gt Callback owner  arg2                      MyClass  MyClass         EventHandler  handler      private x   4      handler- gt addHandler this  private x      OtherClass  OtherClass         EventHandler  handler      private str    moh        handler- gt addHandler this  private str       void MyClass  Callback MyClass  instance  int x        cout  lt  lt    MyClass  Callback MyClass  instance  int x     gt               lt  lt  6   x   instance- gt private x  lt  lt  endl     void OtherClass  Callback OtherClass  instance  std  string private str        cout  lt  lt    OtherClass  Callback OtherClass  instance  std  string private str     gt               lt  lt    Hello    lt  lt  instance- gt private str  lt  lt  endl     int main int argc  char   argv        EventHandler  handler      handler   new EventHandler        MyClass  myClass   new MyClass        OtherClass  myOtherClass   new OtherClass

User · Answer

A complete working example from the code above     for C  11    include  lt stdlib h gt   include  lt stdio h gt   include  lt functional gt    if   cplusplus  lt   199711L    error This file needs at least a C  11 compliant compiler  try using     error      g   -std c  11     endif  using namespace std   class EventHandler       public          void addHandler std  function lt void int  gt  callback                printf   nHandler added                      Let s pretend an event just occured             callback 1                  class MyClass       public          MyClass int              Note  No longer marked  static   and only takes the actual argument         void Callback int x        private          EventHandler  pHandler          int private x      MyClass  MyClass int value        using namespace std  placeholders     for   1       pHandler   new EventHandler        private x   value      pHandler- gt addHandler std  bind  amp MyClass  Callback  this   1       void MyClass  Callback int x           No longer needs an explicit  instance  argument         as  this  is set up properly     printf   nResult  d n n    x private x          Main method int main int argc  char const  argv           printf   nCompiler  ld n     cplusplus       new MyClass 5       return 0         where  1 is your  cpp file name    this is the command used     g   -std c  11 -Wall -o  1  1 cpp    chmod 700  1       1   Output should be   Compiler 201103  Handler added    Result 6

User · Answer

MyClass and YourClass could both be derived from SomeonesClass which has an abstract  virtual  Callback method  Your addHandler would accept objects of type SomeonesClass and MyClass and YourClass can override Callback to provide their specific implementation of callback behavior

[c++] C++ callback using class member

Examples related to c++

Examples related to function

Examples related to callback

Examples related to member