Virtual inheritance and interfaces
c++, virtual-inheritance
Solution
Using multiple inheritance coupled with virtual inheritance is an appropriate design choice when it comes to separating interface and implementation hierarchies. E.g., see: "When virtual inheritance IS a good design?"
Pros:
- less code duplication: interface implementations made re-usable
- switching between the interface implementations for a class is easy
- just looking at base classes tells a lot about concrete implementations
Cons:
- dispatching performance hit cased by virtual inheritance
- uncommon pattern, needs to be explained/documented for external/new people
Alternatives:
no good alternatives if interface hierarchy is needed
otherwise, the hierarchy could be broken into individual interfaces
It could look something like:
struct IA
{
virtual ~IA() = default;
virtual void a() = 0;
};
struct A: public IA
{
virtual ~A() = default;
virtual void a() {}
};
struct IB
{
virtual ~IB() = default;
virtual void b() = 0;
};
struct B: public IB
{
virtual ~B() = default;
virtual void b() {}
};
struct C: public A, public B
{
};
Problem
``` class IA { public: virtual void a() = 0; }; class A: virtual public IA { public: virtual void a() { } }; class IB: virtual public IA { public: virtual void b() = 0; }; class B: virtual public IB, public A { public: virtual void b() { } }; ``` Do you always inherit your interfaces as virtual as I do above? If not, how would you impement the above code?