I encounter a scenario of nested interface declarations and implementation, and I am looking for a better solution. The two possible solutions I can think of are either have wrapper objects in implementation, or using diamond inheritance. I am not satisfy with the wrapper objects as if I have over ten methods in each interface then there will be a lot of wrapper methods in each level of implementation class. The diamond inheritance implementation is more concise but I am told to avoid using diamond inheritance whenever possible. Can anyone suggest an alternative better solution than the 2 in this question?
The wrapper object implementation is
class IA
{
public:
virtual void MA() = 0;
};
class IB : public IA
{
public:
virtual void MB() = 0;
};
class IC : public IB
{
public:
virtual void MC() = 0;
};
class ID : public IC
{
public:
virtual void MD() = 0;
};
// ------------------------
class ImplA : public IA
{
public:
void MA() { /* do A */ }
};
class ImplB : public IB
{
public:
void MA() { a.MA(); }
void MB() { /* do B */ }
private:
ImplA a;
};
class ImplC : public IC
{
public:
void MA() { b.MA(); }
void MB() { b.MB(); }
void MC() { /* do C */ }
private:
ImplB b;
};
class ImplD : public ID
{
public:
void MA() { c.MA(); }
void MB() { c.MB(); }
void MC() { c.MC(); }
void MD() { /* do D */ }
private:
ImplC c;
};
The diamond inheritance examples is
class IA
{
public:
virtual void MA() = 0;
};
class IB : public virtual IA
{
public:
virtual void MB() = 0;
};
class IC : public virtual IB
{
public:
virtual void MC() = 0;
};
class ID : public virtual IC
{
public:
virtual void MD() = 0;
};
// ------------------------
class ImplA : public virtual IA
{
public:
void MA() { /* do A */ }
};
class ImplB : public IB, public virtual ImplA
{
public:
void MB() { /* do B */ }
};
class ImplC : public IC, public virtual ImplB
{
public:
void MC() { /* do C */ }
};
class ImplD : public ID, public ImplC
{
public:
void MD() { /* do D */ }
};
