The discrepancy between interfaces and dynamic_cast

1. Introduction
2. dynamic_cast<> on C++ classes
3. COM in C++
4. dynamic_cast<> on Delphi classes
5. A pragmatic workaround
6. References
7. Comments

Introduction

• The binary layout of a COM object begins with a pointer to the Virtual Method Table.
  
• The Virtual Method Table contains three function pointers: QueryInterface(), AddRef() and Release().

dynamic_cast<> on C++ classes

IMyInterface* intf = createObject ();
MyClass* mc = dynamic_cast <MyClass*> (intf);

void    __far * DEFCC   __DynamicCast(void      __far * objectPtr,
				      void      __far * vtablePtr,
				      void      __far * srctypPtr,
				      void      __far * dsttypPtr,
				      int               reference);

COM in C++

class IUnknown
{
public:
    virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void **ppvObject) = 0;
    virtual ULONG STDMETHODCALLTYPE AddRef (void) = 0;
    virtual ULONG STDMETHODCALLTYPE Release (void) = 0;
};

typedef struct _IUnknownVtbl
{
    HRESULT (STDMETHODCALLTYPE * QueryInterface) (
        IUnknown* This,
        REFIID    riid,
        void**    ppvObject);

    ULONG (STDMETHODCALLTYPE * AddRef) (
        IUnknown* This);

    ULONG (STDMETHODCALLTYPE * Release) (
        IUnknown* This);
} IUnknownVtbl;

struct IUnknown
{
    const IUnknownVtbl* lpVtbl;
};

template <class T> // does not restrict arguments to class types!
    class MyTemplate
{
public:                          // publicly visible

    static long counter;         // class variable

    const MyTemplate& operator = (const MyTemplate&); // takes and returns a reference
                                                      // to a constant object

    T getValue (void) const;     // can be called for constant objects

    ~MyTemplate (void) throw (); // specifies that the destructor cannot
                                 // throw an exception

    virtual void foo (void);     // a virtual function that takes no parameters

    void bar (void*);            // a function that takes an untyped pointer
};

struct Derived : public virtual MyTemplate <int> // public virtual inheritance
                                                 // (this is possible as a workaround
                                                 // for the DoD problem)
{
    // ...
};

static long counter; // global variable not visible to other source modules

void foo (void)
{
    static long counter; // global variable not visible to other functions
    throw std::runtime_error ("An error occurred."); // throws an exception
}

dynamic_cast<> on Delphi classes

void	*__fastcall _EXPFUNC __DynamicCastVCLref(void *ptr, void *targetVMT);
void	*__fastcall _EXPFUNC __DynamicCastVCLptr(void *ptr, void *targetVMT);

#include <System.hpp>
#include <unknwn.h>
#include <tchar.h>
#pragma hdrstop

#define DO_QUERYINTERFACE(I)                    \
    if (__uuidof (I) == riid)                   \
    {                                           \
        AddRef ();                              \
        *ppvObject = static_cast <I*> (this);   \
        return S_OK;                            \
    }

class TMyDelphiClass : public TInterfacedObject, public IUnknown
{
public:
    virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void** ppvObject)
    {
        DO_QUERYINTERFACE (IUnknown)
        return TInterfacedObject::QueryInterface (riid, ppvObject);
    }

    virtual ULONG STDMETHODCALLTYPE AddRef (void)
    { return TInterfacedObject::_AddRef (); }
    virtual ULONG STDMETHODCALLTYPE Release (void)
    { return TInterfacedObject::_Release (); }
};

class MyCppClass : public IUnknown
{
private:
    LONG refcnt;

public:
    virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void** ppvObject)
    {
        *ppvObject = 0;
        DO_QUERYINTERFACE (IUnknown)
        return E_NOINTERFACE;
    }

    virtual ULONG STDMETHODCALLTYPE AddRef (void)
    { return InterlockedIncrement (&refcnt); }
    virtual ULONG STDMETHODCALLTYPE Release (void)
    {
        LONG ref = InterlockedDecrement (&refcnt);
        if (ref == 0)
            delete this;
        return ref;
    }
};

int _tmain (void)
{
        // (The _di_-prefixed interfaces are typedefs to the DelphiInterface<>
        // smart pointer which imitates Delphi's intrinsic interface handling.)
    _di_IUnknown i;
    i = new TMyDelphiClass;

        // This should return 0, but instead, it raises an AV because it
        // invokes _DynamicCast() which expects a C++-style VMT layout.
    MyCppClass* cc = dynamic_cast <MyCppClass*> (&*i);

        // This could fail at compile time, but the compiler apparently is
        // not smart enough. Therefore, supposed that we survived the first AV
        // by sheer luck, we would get a second one here for the same reason.
    TMyDelphiClass* dc = dynamic_cast <TMyDelphiClass*> (&*i);
}

A pragmatic workaround

class __declspec(uuid("{22807D4C-1770-472D-A44B-4D87B53D0189}")) MySelfAwareClass
    : public MyCppClass
{
    virtual HRESULT STDMETHODCALLTYPE QueryInterface (REFIID riid, void **ppvObject)
    {
        DO_QUERYINTERFACE (MySelfAwareClass)
        return MyCppClass::QueryInterface (riid, ppvObject);
    }
};

int _tmain (void)
{
    _di_IUnknown i = new MySelfAwareClass;

    MySelfAwareClass* msac;
    i->QueryInterface (__uuidof (MySelfAwareClass),
        reinterpret_cast <void**> (&msac));
}

References

Comments