Re: When might it make sense to use inheritance when templates (compile-time
polymorphism) is enough?
On 8/17/2013 5:37 PM, K. Frank wrote:
Prior to templates, if you wanted to reuse code across
different types, you would use inheritance / polymorphism
where your different types would derive from a common
base type that offered the capabilities needed by your
Now (with templates) if you know at compile time which
objects are of which concrete types you can use templates.
(If the concrete type of an object is only determined at
run time, you still need inheritance.)
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.
When you use "duck typing", you only care about the "duck" part of your
type, and never about anything else. Granted, the class (the "duck")
should take care of itself, of course. When you use inheritance, the
bigger part is pulled in. From how I feel about it, inheritance is a
bit more flexible and a bit more powerful than "compile time
polymorphism" achievable through "duck typing".
Assume for this question that the code is special purpose,
so we're not trying to write some general, open-ended
library. That is, the code will be reused across a
smallish number of different types that are all being
designed together, and will not be extended to new types
in the future.
That's a slippery slope, isn't it? Remember, in the 1970s, when 640
Kbytes was considered "enough for anybody" using a personal computer?
The addressing scheme in the microprocessor's "real" mode was limited to
20 bits of addressable space because they *assumed* that there will be a
limited use to the whole thing...
So, don't mean to snap at you. Inheritance has its place. Public
inheritance implements Liskov's substitution principle. Private
inheritance is a way to pull in all the functionality ("implemented in
terms of") without having to recompile everything.
"Duck typing" on the other hand is the freedom from the limitations
imposed by inheritance. Use it whenever you feel confined or obstructed
by too much dependence between types. Now, flexibility and freedom are
not the same thing, so don't try to catch me because I just said that
"inheritance is more flexible". "Duck typing" is not flexible, it's loose.
Also assume that efficiency isn't a concern, so that we
don't care about the cost of vtables or the cost (size)
of duplicated template code.
Efficiency isn't a concern unless (or until) it's _confirmed_ to suffer
and then one should use proper tools to discover the cause of
inefficiency. One should never *assume* that the use of vtables or
inheritance is somehow inferior in terms of efficiency to templates.
Both methods are ways to *model* your environment, to *represent* your
design. Efficiency gained by direct calls (instead of polymorphic ones)
is usually borrowed from something else, like clarity or maintainability...
Take my comments with a grain of salt. I've not exercised my skills in
C++ design in some months...
I do not respond to top-posted replies, please don't ask