Why is it a poor approach to build a class by publicly inheriting another class?

Question

I'm studying for my OOP final, and came across a question that has me a bit stumped. The question is "explain why building a Stack class by publicly inheriting a List class is a poor approach. Describe a better solution."

I'm not sure if my answer is right, but is it because of "publicly inheriting..."? And that it would be better to inherit privately instead so that way no class other than Stack would know of the inheritance?

Answer 1

If a derived class publicly inherits from a base class, the derived class is an instance of the base class, potentially with some extra functionality or overridden functionality. In the case of a stack and a list, a stack isn't a list - it logically doesn't perform list operations like searching, concatenating, reversing, etc. - so inheriting from list would not be a good idea.

You could use private inheritance here, but that's not a particularly elegant solution. Instead, you could just implement stack by having it hold a list as a private data member. This is the reason why you often hear "favor composition (having private data members) over inheritance."

Hope this helps!

Answer 2

Private inheritance is also a bad idea here. The key point is really that a Stack isn't a List. While you could have a list implementation that only supports stack like operations this doesn't follow from the definition of a list.

In general you should always prefer composition over inheritance. Inheritance should, ideally, only be used to introduce runtime polymorphism. (Inheritance can sometimes be used for convenience, but you should limit this as a much as possible as it creates possibly unnecessary coupling to the base class).

Answer 3

Maybe it's about not using inheritance and take advantage of composition instead.

Stack has an internal list instead of Stack is a list (which is false: stack is semantically different than a list).

Answer 4

This is because public inheritance affects interface. If Stack publicly inherits List, it will include List interface.

Yes, private inheritance is better approach there. Personally, I prefer using aggregation in such cases.