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.