Re: When might it make sense to use inheritance when templates
(compile-time polymorphism) is enough?
Hi Victor and Paavo!
On Sunday, August 18, 2013 5:54:50 PM UTC-4, Paavo Helde wrote:
"K. Frank" wrote in
news:34bc7d43-ab87-4de0-83a8-40502eef08ce@googlegroups.com:
This is kind of a soft question, but I'm wondering whether
there are situations where inheritance would still be
preferable, even when concrete types are known at compile
time, and a template solution could have been used.
There are plenty of reasons to use inheritance for some kind of
functionality even if run-time polymorphism is not needed (assuming
performance issues are not a concern either way).
- using inheritance imposes more stringent restrictions over the
involved classes than templates, so there is more formal control and
structure
I think in terms of my question, this is probably the
key benefit of inheritance. And I think it contrasts
well with Victor's comment about the template approach
(what he called "duck typing") about which he said:
"it's loose."
So in the template case, we avoid the "nuisance" of
having to derive from a specific base class, while
in the inheritance case, we have the benefit of a
well-defined interface.
I would describe it as follows: Absent concepts, you
can't use templates to specify the required interface
in an organized way -- the requirements are given
implicitly by what the template's implementation does
with the type with which it's instantiated.
For example, in my template example:
template<typename T> void printHasPrintMe (const T& p) {
p.printMeGen();
}
it's only in the implementation that we see that T is
required to have a printMeGen member function.
In my inheritance example, I used an abstract base class to
define a pure interface. This specifies that the derived
type must implement the printMePoly member function:
class Printable {
public:
virtual void printMePoly() const = 0;
};
and we do not need to look at the actual implementation
of the (non-template) printPrintable function:
void printPrintable (const Printable& p) {
p.printMePoly();
}
to see that the printMePoly function is required; we know
this already from the Printable interface.
I wonder how far adding concepts to c++ would go in
giving the template approach these same benefits.
Thanks.
K. Frank