How do I re-use an interface implementation in many classes?

Question

This question could also have been entitled "How to do reference-counting without ATL". Some similar questions have been asked here and here, but in the former a different question was answered and in both cases, ATL is involved. My question is more general to C++ and not so much about COM.

Suppose we have an IUnknown "interface", like so:

class IUnknown
{
public:
    virtual ULONG AddRef() = 0;
    virtual ULONG Release() = 0;
    virtual ULONG QueryInterface(void * iid, void **ppv) = 0;
};

...and let's throw in a few other interfaces that are part of a fictional SDK:

class IAnimal : public IUnknown
{
public:
    virtual IAnimal** GetParents() = 0;
};

class IMammal : public IAnimal
{
public:
    virtual ULONG Reproduce() = 0;
};

Since I am going to be implementing several animals and mammals, I would rather not copy-paste the AddRef() and Release() implementations in every class, so I wrote UnknownBase:

class UnknownBase : public IUnknown
{
public:
    UnknownBase()
    {
        _referenceCount = 0;
    }
    ULONG AddRef()
    {
        return ++_referenceCount;
    }
    ULONG Release()
    {
        ULONG result = --_referenceCount;
        if (result == 0)
        {
            delete this;
        }
        return result;
    }
private:
    ULONG _referenceCount;
};

...so that I may use it to, say, implement a Cat:

class Cat : public IMammal, UnknownBase
{
public:
    ULONG QueryInterface(void *, void**);

    IAnimal** GetParents();
    ULONG Reproduce();
};

ULONG Cat::QueryInterface(void * iid, void **ppv)
{
    // TODO: implement
    return E_NOTIMPL;
}

IAnimal** Cat::GetParents()
{
    // TODO: implement
    return NULL;
}

ULONG Cat::Reproduce()
{
    // TODO: implement
    return 0;
}

...however, the compiler disagrees:

c:\path\to\farm.cpp(42): error C2259: 'Cat' : cannot instantiate abstract class
          due to following members:
          'ULONG IUnknown::AddRef(void)' : is abstract
          c:\path\to\iunknown.h(8) : see declaration of 'IUnknown::AddRef'
          'ULONG IUnknown::Release(void)' : is abstract
          c:\path\to\iunknown.h(9) : see declaration of 'IUnknown::Release'

What am I missing?

Side note - If your `unknownbase` is only present to provide an impl to those two functions and your original interface is only used through it, you can consider moving the impl directly into the interface itself. — Karthik T, Jun 26 '13 at 02:55
Ah, that would be easier, but in this case I don't control `IUnknown` or any of the other interfaces. I'm merely implementing them. — Olivier Dagenais, Jun 26 '13 at 02:58

score 1 · Accepted Answer · answered Jun 26 '13 at 16:01

1

This does not require changing the interface definitions:

template<class I>
class UnknownBase : public I
{
    ...
}

class Cat : public UnknownBase<IMammal>
{
    ...
}

answered Jun 26 '13 at 16:01

David Ching

1,903
17
21

This is called the curiously recurring template pattern: CRTP. – Kaz Apr 18 '14 at 23:24

Captain Obvlious · Answer 2 · 2013-06-27T03:28:56.823

You can use a class template that allows you to specify the base class as a template argument. This will eliminate the need to implement a final override function in the derived class.

You also need to make sure that you declare the member functions with the correct calling convention, return type and parameter types.

template<typename Base>
class UnknownImpl : public Base
{
public:

    UnknownImpl() : _referenceCount(0)
    {
    }

    ULONG STDMETHODCALLTYPE AddRef()
    {
        return InterlockedIncrement(&_referenceCount);
    }

    ULONG STDMETHODCALLTYPE Release()
    {
        ULONG result = InterlockedDecrement(&_referenceCount);
        if (result == 0)
        {
            delete this;
        }
        return result;
    }

private:

    ULONG _referenceCount;
};


class Cat : public UnknownImpl<IMammal>
{
public:
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID, void**);

    IAnimal** GetParents();
    ULONG Reproduce();
};

Thanks for the reminder that I should probably be using `Interlocked[In|De]crement`. — Olivier Dagenais, Jun 27 '13 at 14:28

score 0 · Answer 3 · edited May 23 '17 at 12:11

0

You must inherit using virtual base classes. Change:

class IAnimal : public IUnknown --> class IAnimal : public virtual IUnknown; and

class UnknownBase : public IUnknown --> class UnknownBase : public virtual IUnknown

edited May 23 '17 at 12:11

Community

1
1

answered Jun 26 '13 at 03:53

David Ching

1,903
17
21

That only works if I can control the definition of `IAnimal`, but I can not. – Olivier Dagenais Jun 26 '13 at 15:20

How do I re-use an interface implementation in many classes?

3 Answers3