C++ Method Pointer? - c++

Question

I’m running on Wintel and I want to be able to call a variable method of any object as long as I know the method signature. Is the following assembler correct? Do I need to save/restore ECX? It seems to work but I want to know if I’m missing something. Yeah, yeah, say goodbye type safety, danger is my middle name...
So, why would I want to do this? I have a message distribution system. Business logic subscribes for messages and the distribution system hands them out when they come in. Right now I’m using an interface definition. I have business objects that need to receive multiple message types. Each handler function has a block of if-else statements to figure out the message type. I would like a single class to subscribe to multiple message types and have different methods for each type. I could switch to function pointers, but then I’d have a bunch of static methods and non-static counter parts.
It’s only 3 assembler instructions, how bad could it be?? Looks down the slippery slope
#include <stdio.h>
class A {
public:
A(int i){
m_i = i;
}
void test(int i){
printf("m_i = %i, i = %i\n",m_i,i);
}
private:
int m_i;
};
void callmethod(void *object, const void *function, int i){
__asm {
push [i];
mov ecx, object;
call function;
}
}
int main(){
A a(123);
callmethod(&a,_ADDRESSOF(A::test),456);
return 0;
}
Outputs:
m_i = 123, i = 456
Here's a more detailed example of what I have now and comments explaining what I would like to do.
#include <stdio.h>
#include <unordered_map>
#include <list>
using std::unordered_map;
using std::list;
class IMessage {
};
class MessageHandler {
public:
virtual ~MessageHandler(){}
virtual void HandleMessage(int type, IMessage *message) = 0;
};
class MessageDispatcher {
public:
void Subscribe(int type, MessageHandler *callback){
m_callbacks[type].push_back(callback);
}
void ProcessMessage(int type, IMessage *message){
if (m_callbacks.find(type) != m_callbacks.end()){
list<MessageHandler*> &callbacks = m_callbacks[type];
for (list<MessageHandler*>::iterator i = callbacks.begin(); i != callbacks.end(); ++i){
(*i)->HandleMessage(type,message);
}
}
}
private:
unordered_map<int,list<MessageHandler*> > m_callbacks;
};
class BusinesLogic : public MessageHandler {
public:
BusinesLogic(MessageDispatcher *md){
md->Subscribe(0,this); // I want to put HandleType0 here like this
// md-Subscribe(0,this,HandleType0);
md->Subscribe(1,this); // I want to put HandleType1 here like this
// md-Subscribe(1,this,HandleType1);
}
private:
void HandleType0(IMessage *message){
printf("Got type 0\n");
}
void HandleType1(IMessage *message){
printf("Got type 1\n");
}
virtual void HandleMessage(int type, IMessage *message){
// I want to do away with this switch block and let the MessageDispatcher
// class call into the HandleType0 and HandleType1 methods directly
// without using static methods
switch (type){
case 0:
HandleType0(message);
break;
case 1:
HandleType1(message);
break;
}
}
};
int main(){
MessageDispatcher md;
BusinesLogic bl(&md);
md.ProcessMessage(0,nullptr);
md.ProcessMessage(1,nullptr);
return 0;
}

Answer 1

You want to use pointers to members like Kay suggested in his first comment.
A simple way do this would be something like the following example:
virtual void HandleMessage(int type, IMessage *message){
typedef void (BusinesLogic::*handler_mfn_type)(IMessage *);
static const handler_mfn_type dispatch_table[] = {
&BusinesLogic::HandleType0,
&BusinesLogic::HandleType1
};
handler_mfn_type mfn = dispatch_table[type];
(this->*mfn)(message);
}
No inline assembler and no static functions. No subscribing to the methods themselves either, but I'm not sure if that's a bad thing.
If you really want to be able to pass the method in the Subscribe call then you'll need to wrap it in a class that bundles the (pointer to) method with a pointer to the object. There's no escaping the fact that you need both to invoke a method.
Create a base class and a template like this:
class callback_base {
public:
virtual void call_handler(IMessage *) = 0;
};
template <class T>
class callback: public callback_base {
typedef void (T::*mfn_type)(IMessage *);
T *obj;
mfn_type mfn;
public:
callback(T *a, mfn_type b): obj(a), mfn(b) {}
virtual void call_handler(IMessage *msg) {
(obj->*mfn)(msg);
}
};
And use it like this:
md->Subscribe(0,new callback<BusinesLogic>(this, &BusinesLogic::HandleType0));
md->Subscribe(1,new callback<BusinesLogic>(this, &BusinesLogic::HandleType1));
void Subscribe(int type, callback_base *cb){
m_callbacks[type].push_back(cb);
}
void ProcessMessage(int type, IMessage *message){
...
for (list<callback_base *>::iterator i = callbacks.begin(); i != callbacks.end(); ++i){
(**i).call_handler(message);
}