Re: stroustrup, void*, and reinterpret_cast
kanze wrote:
It sends the wrong message to the reader.
When I see a reinterpret_cast in code, I immediately assume that
there is something very delicate and implementation dependant
going on. When I see a static_cast, I suppose that while you
are subverting the type system somewhat, it is within more
reasonable bounds, and is portable---I don't have to pay
particular attention to it when porting to another system, for
example.
There is a specific scenario that I have never been clear about in all
these years w.r.t reinterpret_casts.
In MSFT's COM-land, there is an API called CoCreateInstance -- its last
parameter is of type void**. This API is used to get a pointer to the
interface (abstract class to be precise) you are interested in. So
people always do something like this:
struct IUnknown
{
virtual void QueryInterface(REFIID riid, void** ppv) = 0;
virtual void AddRef() = 0;
virtual void Release() = 0;
};
struct ISomeInterface : public IUnknown
{
virtual void DoIt() = 0;
};
ISomeInterface* isi;
CoCreateInstance(......,...., reinterpret_cast<void**>(&isi));
Internally a lot of hocus-pocus happens and the API ends up calling an
implementation of a standard IUnknown method called QueryInterface that
returns a pointer to ISomeInterface like so:
class SomeInterfaceImpl : public ISomeInterface
{
void QueryInterface(REFIID riid, void** ppv)
{
*ppv = static_cast<ISomeInterface*>(this);
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
}
// remaining implementations elided for clarity
};
Have the proper casts been used in the above code? Can you explain why
reinterpret_cast is needed in places where its been used?
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]