lisch@mentor.com (Ray Lischner) (11/18/89)
I have a problem that seems to require parametric types to solve.
I have a set of collection classes (based on OOPS), where every class
is derived from class Object. The collection classes manage
collection of Objects. By deriving all the useful classes from
Object, one can easily use the collections.
For example, an OrderedCltn is a collection of Objects in a
user-defined order. Each Object defines virtual member functions
hash(), isEqual(), and others, that are used by the collection
classes. For example Dictionary uses hash() to obtain an integer key
for an Object to use in a hash table. To see if an object is already
in the Dictionary, isEqual() is called on Objects that hash to the
same value. Obviously, this scheme does not work with classes that
are not derived from Object.
I also have a set of classes for representing parse trees for a
language. The base class for the parse trees is called Vnet; it
includes several virtual member functions for doing useful parse-tree
stuff. There are a few major derived classes from Vnet: Vnet_expr
(for expressions), Vnet_stmt (for statements), etc.
Some of the Vnet classes need to be managed in a Dictionary (one of
the collection classes). To do so, I derived Vnet_identifier from
LookupKey, making it easy to use a Vnet_identifier as a key in the
dictionary.
Some identifiers are also used in expressions (such as variables), so
I derive Vnet_identifier from Vnet_expr, also. The resulting
derivations are shown below:
class Vnet : public Object { ... };
class Vnet_expr : public Vnet { ... };
class LookupKey : public Object { ... };
class Vnet_identifier : public LookupKey, public Vnet_expr { ... };
The problem in this case is that Vnet_identifier has two Objects: one
from LookupKey, and one from Vnet (via Vnet_expr).
Well, that's what virtual base classes are for; I could make all the
derivations from Object be virtual:
class Vnet : virtual public Object { ... };
class Vnet_expr : public Vnet { ... };
class LookupKey : virtual public Object { ... };
class Vnet_identifier : public LookupKey, public Vnet_expr { ... };
Now Vnet_identifier has only one Object, which solve that problem.
Another problem crops up, however, in the collection classes.
By operating on collections of Objects, it is possible to implicitly
convert a pointer to a Vnet_identifier into a pointer to an Object,
but it is impossible to convert a pointer to an Object back into a
pointer to a Vnet_identifier, even when I know that the collection
contains only Vnet_identifiers.
I could pervert my inheritance graph so that a Vnet_expr is not
derived from Object. This would make it unambiguous how to convert an
Object* to a Vnet_identifier*, but then I could not put a Vnet_expr in
a collection. Since I need a List of expressions, this solution is
not possible.
The heart of the problem lies in the collection classes, which are
really collections of Objects, where an Object is used only as a
virtual base class. The best solution is to use collections of
derived classes, such as a Dictionary of Vnet_identifiers. This means
I need real parametric types. I could rewrite all the collection
classes to use the generic.h mechanism (described in section 7.3.5 of
Stroustrup's book), but that is really ugly and unmaintainable.
So, can anyone out there in netland offer a useful solution?
Thank you for any help you can offer.
--
Ray Lischner UUCP: {uunet,tektronix,decwrl}!sequent!mntgfx!lisch