Tuesday, November 22, 2011

std::function

A colleague recently asked for suggestions on how to pass a pointer to a callback function without having the caller know whether the function is a free function or member function.  I suggested std::function (previously know as std::tr1::function or boost::function) but later realized I'd never actually used it.  Seems like now might be a good time for an experiment.

First, let's define a class that others might want to observe:
struct Caller
{
  typedef std::function< void() > Callback;
    
  void RegisterCallback( Callback const & callback )
  {
    callbacks.push_back( callback );
  }
    
  void Notify() const
  {
    std::for_each( callbacks.begin(), callbacks.end(), []( Callback const & callback )
    {
      callback();
    });
  }
    
  std::vector< Callback > callbacks;
};
Next, a free function we want to be called:
void GlobalFunction()
{
  std::cout << "GlobalFunction" << std::endl;
}
As well as a functor:
struct Functor
{
  void operator()()
  {
    std::cout << "Functor" << std::endl;
  }
};
And finally, a member function on an observing class:
struct Observer
{
  void Update()
  {
    std::cout << "Observer::Update" << std::endl;
  }
};
Hooking everything up:
  Caller caller;
    
  Observer observer;
    
  caller.RegisterCallback( &GlobalFunction );
  caller.RegisterCallback( Functor() );
  caller.RegisterCallback( std::bind( &Observer::Update, observer ) );
    
  caller.Notify();
Gives the output we'd expect:
GlobalFunction
Functor
Observer::Update
But how could we implement an UnregisterCallback method on the Caller class? std::function is neither LessThanComparable nor EqualityComparable so storing them in a set (ordered or otherwise) won't work. Seems that Boost.Signals might be a better fit for this task.

0 comments:

Post a Comment