Re: polymorphic base class pointers and template classes
awm129@gmail.com wrote:
Thanks for the response! Here is a bit more background on what I'm
trying to do:
These legacy structures are a bunch of different messages. I'm
reading these off a pipe and they come in randomly. I want to pass
these to a factory to create the correct type of object and then I
want to pass these messages to several different handlers. These
handlers should only process the messages for which they are
interested in and just ignore the others. I had planned to have each
handler inherit from a base handler that knows how to process the
generic message type (type Base in my example above). Each derived
handler would have overloaded processing methods for the message types
that they are interested in. That way I can call Process( Base* s )
on a derived handler and all generic messages are passed through while
certain message types are caught and processed by an overloaded form
of Process() in the derived handler. The only place the messages need
to be handled differently based on type is inside the handlers, I want
to treat them gernerically outside the handlers; thus my desire for a
base class pointer. This may be easier to see with more psudo code,
but I can't post any at the moment. Does this clarify my intents at
all? Thanks again.
Yes, it does clarify. And it also gives an opportunity to point out that
your design has a few pitfalls you need to look out for.
The first one is that overload resolution is done on the *static* (or
declared) type. In order to be able to call the correct overload of the
processing functions, if you only have a pointer to the base class
available, you need a double-dispatch mechanism.
See the output from this program for what I mean:
#include <iostream>
using namespace std;
struct MessageA {};
struct MessageB {};
class MessageBase;
template <class T> class Message;
void Process(const MessageBase*);
void Process(const Message<MessageA>*);
class MessageBase
{
public:
virtual ~MessageBase() {}
virtual void call_Process() = 0;
};
template <class T>
class Message : public MessageBase, public T
{
Message() : MessageBase(), T() {}
public:
virtual void call_Process()
{
Process(this);
}
static Message<T>* create() { return new Message<T>(); }
};
void Process(const MessageBase*)
{
cout << " Process(const MessageBase*)" << endl;
}
void Process(const Message<MessageA>*)
{
cout << " Process(const Message<MessageA>*)" << endl;
}
int main()
{
MessageBase* message1 = Message<MessageA>::create();
MessageBase* message2 = Message<MessageB>::create();
cout << "Calling \"Process\" directly" << endl;
Process(message1);
Process(message2);
cout << "Calling \"Process\" indirectly" << endl;
message1->call_Process();
message2->call_Process();
}
Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://c-faq.com/
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/