Re: Downcast with smart pointers?
You can't change the type of an object. When you instantiate a HttpMsg, you
can't change the type to a HttpRequest or HttpResponse after that.
You can make a 'factory', a function that parses a buffer and gives you
either a HttpRequest or a HttpResponse:
SmartPtr<HttpMsg> createMessage(const std::string& buffer)
{
// ... parse buffer...
if (isRequest)
return SmartPtr<HttpMsg>(new HttpRequest(buffer));
else
return SmartPtr<HttpMsg>(new HttpResponse(buffer));
}
Yes, I'm doing this now to create the appropriate object. But my
problem is that I'm passing this to a method that takes either request
or responses, so its parameter is a HttpMsg. And now I'm having two
problems: neither upcasting nor downcasting seem to work!
In some situations, I'd like to pass some of these objects to a
function, so assuming I have a generic function (because it could
either accept a request or response):
void foo(const SmartPtr<HttpMsg>& msg);
Then inside this function, I'd need to instantiate the correct object.
But how to do it? I tried:
SmartPtr<HttpResponse> resp = msg;
But of course doesn't work. If I were using normal pointers, then I'd
do dynamic_cast<HttpResponse*>(msg) and everything ok.
Get the raw pointer and do a dynamic_cast. Or use another smart pointer
like boost::shared_ptr (which is tr1::shared_ptr), that has a dynamic_cast
replacement: dynamic_pointer_cast<>.
Yes, unfortunately I'd like to make my own, for simplicity purposes,
and for space. Also, some environments I use don't have std library
available.
Well, smart pointers transfer ownership. If your foo() function here
doesn't store the HttpMsg object, it could take a const reference instead:
void foo(const HttpMsg& msg);
That would be one option. I assume it is safe enough.. but my problem
is that these messages are passed from one side to another, including
different threads..
Thanks!