Admittedly, this is a homework problem but I have tried to figure it out on my own. Just want to make sure I get it correct. So far, the only design pattern I believe to be correct would be the Adapter design pattern. I could implement an Adapter class to publicly inherit from class C and privately from class D and instantiate the following:
D *d = new Adapter();
d->foo();
However, would this qualify as subtyping?
The problem:
Suppose we have the following class:
class C { /* ... */ public: int foo (); int bar (); };
Also suppose that this class is only available in compiled form, i.e., that it cannot be modified. Now
we want to add an alternative implementation that only has a method foo()
but that does not have a
method bar()
and does not inherit the data members from class C. I.e., this new class D would have
the structure
class D /* ... */ { public: int foo (); };
but it cannot inherit from class C.
Suppose we want to maintain a list of objects that can be from either classes C or D. Explain how
you can design this list data structure, traverse the list, and call foo()
on each element, such that the
appropriate method C::foo()
or D::foo()
is executed depending on the type of the object. Do
not use either if-statements or structural subtyping.