Re: Are homonymous non-template and template classes incompatible?
Barry Kelly wrote:
"kanze" <kanze@gabi-soft.fr> wrote:
[...]
Why not use a different name? One can ask the same question
about overloaded functions. Using the same name for the same
concept has a certain elegance, I suppose. If I have some
Foo<Bar> and some Foo<Baz> and other kinds of Foo<>, and I
need to do something requiring dynamic dispatch with all kinds
of Foo, why introduce a new name?
Because a base class isn't conceptually the same thing as a
derived class.
By Liskov substitution principle, the vast bulk of code which
works with the base class should work when passed the subclass
too - otherwise the base class is badly designed, the
subclasses are badly designed, and/or the code is badly
designed.
Do you really think so? What about classes which derive from
the Base class? Do you think that they can equally derive from
one of the derived classes? And of course, in the other
direction... The base class will often be abstract; in almost
no case will it be designed to be used as an object itself.
To me, these are significant differences. Enough that I want a
different name.
They are, in fact, radically different -- about
as different as addition and subtraction,
Nobody, to my knowledge, has suggested that a reasonable
implementation of addition in a programming language is by
subclassing subtraction, or vice versa. What class invariants
could encompass the specification and semantics of addition
that always hold for subtraction? At best, both can be
subclasses of some kind of Binary Operator dealing with
quantities.
or as adding or removing an element from a collection.
Again, adding and removing to and from a collection aren't
subclasses and superclasses of one another, either way. So, I
don't accept that subclassing means that the subclass is as
different from the base class as subtraction is from addition.
That wasn't my point. My point is that deriving from/being
derived from are as different as addition/subtraction. If the
role of a class is to be a base class, it's role is NOT that of
a most derived class. And when the roles are different, the
names should also be.
FWIW: this "feature" already exists in C++, sort of:
enum BaseClass { baseClass } ;
template< typename T = BaseClass >
class Whatever ;
template<>
class Whatever< BaseClass >
{
// ...
} ;
template< typename T >
class Whatever : public Whatever< BaseClass >
{
// ...
} ;
Of course, you cannot simply say:
template< typename T >
class Whatever : public Whatever // ...
because by definition, in the template definition of
Whatever<T>, all use of Whatever that isn't followed by a
template argument list is considered to be Whatever<T>. The
above would be the equivalent of defining a class which derives
from itself.
(This description of the "feature" as it is in C++ isn't so much
for you, as for the original poster, or others who seem to want
this feature.)
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]