Cast DirectX interfaces to IUnknown pointers

Question

Having quite a few interfaces in my code, I wanted to encapsulate repeating Release code in another method and not in a macro because this is C++ and I hate using macros. My initial attempt was to write a method such as

void SafeRelease(IUnknown **ppInterface) {
    if(*ppInterface) {
        (*ppInterface)->Release();
        (*ppInterface) = nullptr;
    }
}

however applying this method to a IDirect3DSurface9 * e.g. like SafeRelease(&mySurface) yields the error IDirect3DSurface9 ** is incompatible with IUnknown **.

1. What am I doing here wrong?
2. Is there a better approach (hopefully not using macros) to implement such a function?

Answer 1

Here's my method:

template <typename T> void SafeRelease(T*& ptr)
{
    if(ptr)
    {
        ptr->Release();
        ptr = nullptr;
    }
}

Example usage:

IDirect3DDevice9 *pD3DDevice = NULL;
d3d->CreateDevice(..., &pD3DDevice);
SafeRelease(pD3DDevice);

You may inline this function if you want.

Answer 2

You could use a template:

template<class DXInterface>
void SafeRelease(DXInterface **ppInterface) {
    if(*ppInterface) {
        (*ppInterface)->Release();
        (*ppInterface) = nullptr;
    }
}

You could also use a std::unique_ptr or std::shared_ptr to automatically cleanup:

#include <memory>
#include <iostream>

struct Releaser {
   template<class DXInterface>
   void operator()(DXInterface *pInterface) const {
       if(pInterface) {
           pInterface->Release();
       }
   }
};

// For illustrative purposes only (supplied in DX9 headers)
struct IDirect3DSurface9 { void Release() { std::cout << "Released surface\n";} };
struct IDirect3DTexture9 { void Release() { std::cout << "Released texture\n";} };

void DX9CreateSurface( IDirect3DSurface9** surface ) 
{ 
    *surface = new IDirect3DSurface9();
}

void DX9CreateTexture( IDirect3DTexture9** texture ) 
{ 
    *texture = new IDirect3DTexture9();
}

// Your factory functions
IDirect3DSurface9* createSurface( /*init params go here*/ )
{
    IDirect3DSurface9* surface;
    DX9CreateSurface( &surface );
    return surface;
}

IDirect3DTexture9* createTexture( /*init params go here*/ )
{
    IDirect3DTexture9* texture;
    DX9CreateTexture( &texture );
    return texture;
}

int main()
{
  typedef std::unique_ptr<IDirect3DSurface9, Releaser> SurfacePtr;
  typedef std::unique_ptr<IDirect3DTexture9, Releaser> TexturePtr;

  SurfacePtr surface( createSurface() );
  TexturePtr texture( createTexture() );
  // ... use surface and texture here
  // Automatically released here when their lifetimes ends.
}

Note that they use the same Releaser, and note that a call to surface.reset() would also release the interface and would set the pointer inside the unique_ptr to null to boot. These two objects could be members of your class rather than objects in main().

Answer 3

What am I doing here wrong?

I just had the same question, also for COM SafeRelease. So here goes:

void SafeRelease(IUnknown **ppInterface) 
...
IDirect3DSurface9 * mySurface = new ...
...
SafeRelease(&mySurface);

IDirect3DSurface9 *, by virtue of inheritance, can be cast to IUnknown *. But, counterintuitively, IDirect3DSurface9 ** cannot be cast to IUnknown **. If it were allowed, then inside your SafeRelease(IUnknown**) you could do the following:

// obtain a pointer to an instance of some random subinterface of IUnknown
*ppInterface = pMyRamdomComInterfacePointer;

And thus we would have stored a pointer to some random IUnknown derivative in a pointer to IDirect3DSurface9. That would violate the C++ type system. Which is why casting any other type but T** to T** is not allowed. In other words, a variable of type T** can only be assigned a ppT (a value of type T**) and not a ppSomeSubytpeOfT.

Compare this one: How come a pointer to a derived class cannot be passed to a function expecting a reference to a pointer to the base class? And this one: Casting double pointers of base classes.

For COM SafeRelease, either a template (as suggested here) or a macro will do.