Generic notify function foo or bar object

Consider

# include <iostream>
# include <vector>

// Event delegate interface class
struct EventHandlerDelegate {
   typedef void ( EventHandlerDelegate::*handler_fp )( int );
   virtual void handle( int ) = 0;
   virtual ~EventHandlerDelegate(){}
};

// Pump_1 event handler
struct Pump_1 : EventHandlerDelegate {
   void handle( int e ) { std::cout << " Pump_1 notified " << e <<
std::endl; }
};

// Pump_2 event handler
struct Pump_2 : EventHandlerDelegate {
   void handle( int e ) { std::cout << " Pump_2 notified " << e <<
std::endl; }
};

// Our functor (modified to handle polymorphic functions)
template < typename classT, typename memfuncT >
class functor {
   memfuncT memfunc_;
   classT * class_;
public:
   functor()
   : class_ ( 0 )
   , memfunc_( 0 )
   {}

   functor(classT * c, memfuncT f)
   : class_( c )
   , memfunc_( f )
   {}

   void operator()( int e ) {
     if( class_ && memfunc_ ) {
       (class_->*memfunc_)( e );
         }
   }
   ~functor() { delete class_; }
};

// Friendly typedef of our functor for this specific usage
typedef functor<EventHandlerDelegate,
EventHandlerDelegate::handler_fp> EventHandlerFunctor;

// An event handler that can handle 2 events (Pump_1 and Pump_2)
class EventHandler {

   typedef std::vector<EventHandlerFunctor *> handler_t;
   typedef handler_t::const_iterator hciter;
   typedef handler_t::iterator iter;
   handler_t handler_;

public:
         // Log events and handlers in a map
   void Attach(EventHandlerFunctor * func) {
     handler_.push_back(func);
   }

   // Extract handler from map and call polymorphic handle() function
   // Gets called in the context of the base class but dynamic binding
ensures
   // the handler for the correct delegate class is called.
   void Notify( int e ) {
     for( hciter itr = handler_.begin() ; itr != handler_.end() ; +
+itr) {
           EventHandlerFunctor * func = (*itr);
           (*func)( e );
         }
   }

   // Clear up the handlers
   ~EventHandler() {
      for( hciter itr = handler_.begin() ; itr != handler_.end() ; +
+itr ) {
            delete *itr;
          }
    }
};

enum MSG_TYPE { _1M, _2M };
class Foo {};
class Bar {};

int main() {

   EventHandler eh;
   eh.Attach(new EventHandlerFunctor( new Pump_1,
&EventHandlerDelegate::handle ) );
   eh.Attach(new EventHandlerFunctor( new Pump_2,
&EventHandlerDelegate::handle ) );

   eh.Notify( _1M );
   eh.Notify( _2M );

}

Notification (Notify) supports integer types. How can I modify source
to support any object - for instance a foo or bar object (I'm
currently going around in circles)? I suspect each pump would have
to use the C++ type system to determine the appropriate type?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]