Multiple inheritance problem

I'm having some problems with multiple inheritance, in my case where the hiearchy first splits then joins again. Ok, first some background. I'm working on a DLL so I need pure virtual interfaces for each class. In one case I have one base class and several classes inherited from that one, call them

Code:

class IBase
{
  public:
    virtual void Stuff() = 0;
};

class ISub1 : public IBase
{
  public:
    virtual void Junk() = 0;
};

class ISub2 : public IBase
{
  ... //etc...
};

The base class has a (in the DLL hidden) implementation:

Code:

class CBase : public IBase
{
  public:
    virtual void Stuff()
    {
      //Implementation
    }
};

The sub class also has an implementation, but here lies the problem, I don't want to redefine the implementation of Stuff() but use the one defined above so I inherit from CBase too.

Code:

class CSub1 : public ISub1, public CBase
{
  public:
    virtual void Junk()
    {
      //Implementation
    }
};

But alas the compiler does not like this and thinks CSub1 is still an abstract class and cannot be instantiated.

So, my question is (I guess), how can I solve this? I don't want to redefine Stuff() in every subclass I derive.

Make IBase a virtual base of both CSub1 and ISub1. This eliminates ambiguity about your CSub1 having a diamond of death (which means that CSub1 contains two instances of IBase internally, either of which may have a pure virtual function).

Could you give an example, simply inheriting from IBase too gives:

warning C4584: 'CSub' : base-class 'IBase' is already a base-class of 'ISub'

It also eliminates COM binary compatibility, which might not be what Magos wants.

Try to make it explicit:

Code:

class CSub1 : public ISub1, public CBase
{
public:
  using CBase::Junk;
};

Edit: the example Magos is asking for:

Code:

class IBase {};

class ISub1 : virtual public IBase {};

class CBase : virtual public IBase {};

class CSub1 : public ISub1, public IBase {};

DirectX uses this on some classes so it has to be done in some way...

I know. Have you tried the using declaration?

yep, but I fail to see how that could work as it has nothing to do with inheritance...?

It has a lot to do with inheritance. But it indeed doesn't work.

Strictly speaking, DirectX doesn't do this. At least I don't think any object derives from any concrete class.

OK, what about forwarding stubs?

Code:

class IBase
{
public:
	virtual void foo() = 0;
};

class IDerived : public IBase
{
public:
	virtual void bar() = 0;
};

class CBase : public IBase
{
public:
	virtual void foo()
	{
	}
};

class CDerived : public IDerived, CBase
{
public:
	virtual void foo() { CBase::foo(); }

	virtual void bar()
	{
	}
};

int main()
{
	CDerived object;
}

Stubs seems to work ok, and on the user side it still seems like real inheritance. I'm satisfied .