Confused on C++ multiple inheritance

Question

I'm somewhat new to the more advanced features of C++. Yesterday, I posted the following question and I learned about virtual inheritance and the dreaded diamond of death.

Inheriting from both an interface and an implementation C++

I also learned, through other links, that multiple inheritance is typically a sign of a bad code design and that the same results can usually be better achieved without using MI. The question is... I don't know what is a better, single-inheritance approach for the following problem.

I want to define an Interface for two types of Digital Points. An Input Digital Point and an Output Digital Point. The Interface is to be slim, with only what's required to access the information. Of course, the vast majority of properties are common to both types of digital points. So to me, this is a clear case of Inheritance, not Composition.

My Interface Definitions look something like this:

// Interface Definitions
class IDigitalPoint
{
public:
  virtual void CommonDigitalMethod1() = 0;
};

class IDigitalInputPoint : virtual IDigitalPoint
{
public:
  virtual void DigitialInputMethod1() = 0;
};

class IDigitalOutputPoint : virtual IDigitalPoint
{
public:
  virtual void DigitialOutputMethod1() = 0;
};

My implementations look like this:

// Implementation of IDigitalPoint
class DigitalPoint : virtual public IDigitalPoint
{
public:
  void CommonDigitalMethod1();
  void ExtraCommonDigitalMethod2();
}

// Implementation of IDigitalInputPoint
class DigitalInputPoint : public DigitalPoint, public IDigitalInputPoint 
{
public:
  void DigitialInputMethod1();
  void ExtraDigitialInputMethod2();
}

// Implementation of IDigitalOutputPoint
class DigitalOutputPoint : public DigitalPoint, public IDigitalOutputPoint 
{
public:
  void DigitialOutputMethod1();
  void ExtraDigitialOutputMethod2();
}

So how could I reformat this structure, to avoid MI?

Answer 1

"multiple inheritance is typically a sign of a bad code design" - parents that are pure interfaces are not counted in regards to this rule. Your I* classes are pure interfaces (only contain pure virtual functions) so you Digital*Point classes are OK in this respect

Answer 2

(Multiple) inheritance and interfaces tend to needless complications of simple relations.

Here we need only a simple structure and few freestanding functions:

namespace example {
    struct Point { T x; T y; }

    Point read_method();
    void write_method(const Point&)
    void common_method(Point&);
    void extra_common_method(Point&);
} // example

The common_method might be a candidate for a member function of Point. The extra_common_method, which is not so common, might be a candidate for another class encapsulating a Point.

Answer 3

This is exactly the situation in which the standard library does use virtual inheritance, in the std::basic_iostream hierarchy.

So, it may be the rare case where it genuinely makes sense.

However, this depends on exactly the fine details you've removed for clarity, so it isn't possible to say for certain whether a better solution exists.

For example, why is an input point different from an output point? A DigitalPoint sounds like a thing with properties, that might be modeled by a class. A DigitalInputPoint, however, just sounds like ... a DigitalPoint somehow coupled to an input source. Does it have different properties? Different behaviour? What are they and why?

Answer 4

You can go to below link to understand more about multiple inheritance Avoid Multiple Inheritance

Also, in your case, multiple inheritance makes sense!!. You may use composition if you want.

Answer 5

Consider a different approach:

class DigitalPoint
{
public:
  void CommonDigitalMethod1();
  void ExtraCommonDigitalMethod2();
}

// Implementation of IDigitalInputPoint
class DigitalInputPoint
{
public:
  void CommonDigitalMethod1();
  void DigitialInputMethod1();
  void ExtraDigitialInputMethod2();
}

// Implementation of IDigitalOutputPoint
class DigitalOutputPoint
{
public:
  void CommonDigitalMethod1();
  void DigitialOutputMethod1();
  void ExtraDigitialOutputMethod2();
}

To be used like this:

template <class T>
void do_input_stuff(T &digitalInputPoint){
    digitalInputPoint.DigitialInputMethod1();
}

You get an easier implementation with a clearer design and less coupling with most likely better performance. The only One downside is that the interface is implicitly defined by the usage. This can be mitigated by documenting what the template expects and eventually you will be able to do it in concepts to have the compiler check it for you.
Another downside is that you cannot have a vector<IDigitalPoint*> anymore.

Answer 6

Are you really sure that you need 3 interfaces?

class IDigitalPoint
{
public:
    virtual void CommonDigitalMethod1() = 0;
};


enum class Direction : bool { Input, Output };

template <Direction direction>
class DigitalPoint : public IDigitalPoint
{
public:
    void CommonDigitalMethod1() {}
    void ExtraCommonDigitalMethod2() {}

    virtual void DigitialMethod1() = 0;
};

class DigitalInputPoint : public DigitalPoint<Direction::Input>
{
public:
    void DigitialInputMethod1() {}
    void ExtraDigitialInputMethod2() {}

    // This is like DigitialInputMethod1()
    virtual void DigitialMethod1() override
    {}
};

class DigitalOutputPoint : public DigitalPoint<Direction::Output>
{
public:
    void DigitialOutputMethod1() {}
    void ExtraDigitialOutputMethod2() {}

    // This is like DigitialOutputMethod1()
    virtual void DigitialMethod1() override
    {}
};

Answer 7

You could use composition instead of inheritance. Live Example

If the child classes do not use functionality from DigitalPoint, then you can try using CRTP. It can be confusing if you don't understand CRTP, but it works like a charm when it fits properly. Live Example