C / C++ / MFC

1. Define an interface that contains the function:
   

   class ICallable
   {
   public:
       virtual void display(char *msg) = 0;
   };

   
   Note the function is a pure virtual function.
2. Derive the classes that have the function to be called from it:
   

   class A : public ICallable
   {
   public:
       virtual void display(char *msg)
       {
           // A's impelentation here...
       }
   };

3. Your pointer now looks like the following:
   

   ICallable *pPointer;

4. The call through the pointer like this:
   

   pPointer->display("Hello world!");

boost::function<void(char*)> display;

B b;
b.display = boost::bind(&A::display, this);

if (display) display(whatever string you want to display

#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>

class B
{
public:
   boost::function<void(char*)> display;
   void b_test() { if (display) display("test"); }
};

class A
{
public:
   A() { b.display = boost::bind(&A::display, this, _1); }
   void a_test() { b.b_test(); }
   void display(char* s) { std::cout << s << std::endl; }
   B b;
};

int main()
{
   A a;
   a.a_test();
}

Stuart Dootson wrote:

I would implement this using Boost.Function[^] and Boost.Bind[^]:

led mike wrote:

The Visual C++ 2008 Feature Pack has implemented TR1[^]

led mike wrote:

Although, I would prefer using interfaces as Stephen Hewitt posted.

Stuart Dootson wrote:

Also, TR1 doesn't have Boost.Bind in it Frown (or Boost.Lambda, for that matter - even more Frown)

Stuart Dootson wrote:

lambdas are available

Stuart Dootson wrote:

Well, you learn something new every day!