List of pointers to methods of derived classes - c++

Question

I'm trying to create the following in C++:
class A {
SpecialContainer<SpecialType> list_of_callables;
void add_to_container(SpecialType *method); // adds method to the SpecialContainer
};
class B : public A {
void method_1();
};
such that a pointer to method_1 can be inserted into the container using, e.g.,
a.add_to_container(&B::method_1)
and consequently be called in an iteration inside A using for instance
# pseudo code
for item in container
(this->*item)();
(Notice that A does not define method_1).
My question is: is this even possible to do, even if with void*, a boost lib or some
C/C++ hack? If yes, how?
(I'm sorry if the answer is obvious, I came back from Python recently).
So far, I tried using
typedef void (A::*SpecialType)();
and SpecialContainer a std::vector, but with no success since method_1
is obviously from B, i.e. I would have to call
add_to_container(&B::method_1)
which is an invalid compilation.

Answer 1

add_to_container(&B::method_1)
This only works if method_1 was a static member of B. The following code works for me (apart from linking, and std::vector instead of your container class):
class A {
public:
typedef void (*SpecialType)();
std::vector<SpecialType> list_of_callables;
void add_to_container(SpecialType method);
};
class B : public A {
public:
static void method_1();
};
int main()
{
A a;
a.add_to_container(&B::method_1);
return 0;
}
If you want functions bound to specific instances of B check out std::bind if you're using C++11, or boost::bind for older C++.

Answer 2

You can't mix pointers to functions with pointers to member functions, so you cannot implement your callback list in that way.
I have implemented this kind of list many times, in form of a event class. My solution to that problem is to dispatch global handlers and member handlers in two distinct ways, and to use dynamic binding when calling the handlers:
//C#-like event class. It supports global functions and member functions as handlers
template<typename SENDER , typename ARGUMMENTS = void>
class event
{
public:
typedef SENDER& sender_param_type;
typedef ARGUMMENTS& argumments_param_type;
private:
struct handler_data
{
virtual void dispatch( sender_param_type , argumments_param_type ) = 0;
virtual ~handler_data() {}
};
struct global_handler_data : public handler_data
{
typedef std::function<void(sender_param_type , argumments_param_type)> global_handler_type;
global_handler_type handler;
global_handler_data( const global_handler_type& handlerrr ) : handler( handlerrr ) {}
void dispatch( sender_param_type sender , argumments_param_type argumments )
{
handler( sender , argumments );
}
};
template<typename HANDLER_CLASS>
struct member_handler_data : public handler_data
{
typedef void(HANDLER_CLASS::*member_handler_type)( sender_param_type , argumments_param_type);
member_handler_type handler;
HANDLER_CLASS& handler_instance;
member_handler_data( HANDLER_CLASS& handlerrr_instance , const member_handler_type& handlerrr ) : handler_instance( handlerrr_instance ) , handler( handlerrr ) {}
void dispatch( sender_param_type sender , argumments_param_type argumments )
{
(handler_instance.*handler)( sender , argumments );
}
};
std::vector<std::unique_ptr<handler_data>> _handlers;
public:
void add_handler( const typename global_handler_data::global_handler_type& handler )
{
_handlers.push_back( std::unique_ptr<handler_data>( new global_handler_data( handler ) ) );
}
template<typename HANDLER_CLASS>
void add_handler( HANDLER_CLASS& handler_instance , const typename member_handler_data<HANDLER_CLASS>::member_handler_type& handler )
{
_handlers.push_back( std::unique_ptr<handler_data>( new member_handler_data<HANDLER_CLASS>( handler_instance , handler ) ) );
}
void raise_event( sender_param_type sender , argumments_param_type argumments )
{
for(auto& handler : _handlers )
{
handler->dispatch( sender , argumments );
}
}
};
//Non-args evets specialization:
template<typename SENDER>
class event<SENDER,void>
{
public:
typedef SENDER& sender_param_type;
private:
struct handler_data
{
virtual void dispatch( sender_param_type ) = 0;
virtual ~handler_data() {}
};
struct global_handler_data : public handler_data
{
typedef std::function<void(sender_param_type)> global_handler_type;
global_handler_type handler;
global_handler_data( const global_handler_type& handlerrr ) : handler( handlerrr ) {}
void dispatch( sender_param_type sender )
{
handler( sender );
}
};
template<typename HANDLER_CLASS>
struct member_handler_data : public handler_data
{
typedef void(HANDLER_CLASS::*member_handler_type)( sender_param_type );
member_handler_type handler;
HANDLER_CLASS& handler_instance;
member_handler_data( HANDLER_CLASS& handlerrr_instance , const member_handler_type& handlerrr ) : handler_instance( handlerrr_instance ) , handler( handlerrr ) {}
void dispatch( sender_param_type sender )
{
(handler_instance.*handler)( sender );
}
};
std::vector<std::unique_ptr<handler_data>> _handlers;
public:
void add_handler( const typename global_handler_data::global_handler_type& handler )
{
_handlers.push_back( std::unique_ptr<handler_data>( new global_handler_data( handler ) ) );
}
template<typename HANDLER_CLASS>
void add_handler( HANDLER_CLASS& handler_instance , const typename member_handler_data<HANDLER_CLASS>::member_handler_type& handler )
{
_handlers.push_back( std::unique_ptr<handler_data>( new member_handler_data<HANDLER_CLASS>( handler_instance , handler ) ) );
}
void raise_event( sender_param_type sender )
{
for(auto& handler : _handlers )
{
handler->dispatch( sender );
}
}
};
As you can see, the class is designed to dispatch events with two parameters: A reference to the object which raised the event, and the event parameters.
You could use C++11 variadic-templates instead of one aggregate event parameter only, but I have done in this manner because the class had to be compatible with MSVC11.
The class provides exactly the same interface to manage global handlers and member handlers, the add_handler() function is overloaded in that way. The only difference is that member handlers need one object to be called with, so the handler of the event stores a reference to a caller object specified by the user when registers the member handler.
Finally, the class is specialised to allow the user create events without parameters.
Here is an example of its usage:
class rabbit
{
void jump()
{
up.raise
}
}