Collection of Education/collectionofeducationcarat1997.iso/COMPUSCI/CPPTUT.ZIP/CHAP09.TXT

Text File | 1990-07-20 | 14KB | 295 lines

                                                        Chapter 9
                                             MULTIPLE INHERITANCE
                                            AND FUTURE DIRECTIONS

C++ version 2.0 was released by AT&T during the summer of 1989, and
the major addition to the language is multiple inheritance, the
ability to inherit data and methods from more than one class into
a subclass.  Multiple inheritance and a few of the other additions
to the language will be discussed in this chapter along with a few
of the expected future directions of the language.

Several companies have announced their intention of marketing C++
compilers early in 1990, but as of this writing, Borland
International and Zortech are the only two major companies to
actually deliver a product to the marketplace.  The examples in
this chapter have all been compiled and executed using the Borland
C++ compiler version 1.00 but the Zortech compiler was on back
order at the time of this writing, so the example programs could
not be tested with it.

After completing this tutorial, you should have enough experience
with the language to study additional new constructs on your own
as they are implemented by the various compiler writers.  We will
update the entire tutorial as soon as practical following
procurement of any new compiler, but hopefully the language will
not change rapidly enough now to warrant an update oftener than
twice a year.  Please feel free to contact us for information on
updates to the Coronado Enterprises C++ tutorial.


MULTIPLE INHERITANCE
_________________________________________________________________

The major addition to the C++ language with the release of version
2.0 is the ability to inherit methods and variables from two or
more parent classes when building a new class.  This is called
multiple inheritance, and is purported by many people to be a major
requirement for an object oriented programming language.  Some
writers have expressed doubts as to the utility of multiple
inheritance, and we are inclined to agree with them.  To illustrate
the validity of this, it was not easy to think up a good example
of the use of multiple inheritance as an illustration for this
chapter.  In fact, the resulting example is sort of a forced
example that really does nothing useful.  It does however,
illustrate the mechanics of the use of multiple inheritance with
C++, and that is our primary concern at this time.

The biggest problem with multiple inheritance involves the
inheritance of variables or methods from two or more parent classes
with the same name.  Which method should be chosen as the inherited
variable or method if two or more have the same name?  This will
be illustrated in the next few example programs.

                                                         Page 9-1

                                 Chapter 9 - Multiple Inheritance

SIMPLE MULTIPLE INHERITANCE
_________________________________________________________________

An examination of the file named MULTINH1.CPP    ================
will reveal the definition of two very simple      MULTINH1.CPP
classes in lines 4 through 27 named moving_van   ================
and driver.

In order to keep the program as simple as possible, all of the
member methods are defined as inline functions.  This puts the code
for the methods where it is easy to find and study.  You will also
notice that all variables in both classes are declared to be
protected so they will be readily available for use in any class
which inherits them.  The code for each class is kept very simple
so that we can concentrate on studying the interface to the methods
rather than spending time trying to understand complex methods.
As mentioned previously, chapter 12 will illustrate the use of non-
trivial methods.

In line 30, we define another class named driven_truck which
inherits all of the data and all of the methods from both of the
previously defined classes.  In the last two chapters, we studied
how to inherit a single class into another class, and to inherit
two or more classes, the same technique is used except that we use
a list of inherited classes separated by commas as illustrated in
line 30.  The observant student will notice that we use the keyword
public prior to the name of each inherited class in order to be
able to freely use the methods within the subclass.  In this case,
we didn't define any new variables, but we did introduce two new
methods into the subclass in lines 32 through 39.

We declared an object named chuck_ford which presumably refers to
someone named Chuck who is driving a Ford moving van.  The object
named chuck_ford is composed of four variables, three from the
moving_van class, and one from the driver class.  Any of these four
variables can be manipulated in any of the methods defined within
the driven_truck class in the same way as in a singly inherited
situation.  A few examples are given in lines 47 through 56 of the
main program and the diligent student should be able to add
additional output messages to this program if he understands the
principles involved.

All of the rules for private or protected variables and public or
private method inheritance as used with single inheritance extends
to multiple inheritance.



DUPLICATED METHOD NAMES
_________________________________________________________________

You will notice that both of the parent classes have a method named
initialize(), and both of these are inherited into the subclass

                                                         Page 9-2

                                 Chapter 9 - Multiple Inheritance

with no difficulty.  However, if we attempt to send a message to
one of these methods, we will have a problem, because the system
does not know which we are referring to.  This problem will be
solved and illustrated in the next example program.

Before going on to the next example program, it should be noted
that we have not declared any objects of the two parent classes in
the main program.  Since the two parent classes are simply normal
classes themselves, it should be apparent that there is nothing
magic about them and they can be used to define and manipulate
objects in the usual fashion.  You may wish to do this to review
your knowledge of simple classes and objects of those classes.

Be sure to compile and execute this program after you understand
its operation completely.



MORE DUPLICATE METHOD NAMES
_________________________________________________________________

The second example program in this chapter named ================
MULTINH2.CPP, illustrates the use of classes       MULTINH2.CPP
with duplicate method names being inherited into ================
a subclass.

If you study the code, you will find that a new method has been
added to all three of the classes named cost_per_full_day().  This
was done intentionally to illustrate how the same method name can
be used in all three classes.  The class definitions are no problem
at all, the methods are simply named and defined as shown.  The
problem comes when we wish to use one of the methods since they are
all the same name and they have the same numbers and types of
parameters and identical return types.  This prevents some sort of
an overloading rule to disambiguate the message sent to one or more
of the methods.

The method used to disambiguate the method calls are illustrated
in lines 60, 64, and 68 of the main program.  The solution is to
prepend the class name to the method name with the double colon as
used in the method implementation definition.  This is referred to
as qualifying the method name.  Actually, you could qualify all
method calls, but if the names are unique, the compiler can do it
for you and make your code easier to write and read.

Be sure to compile and execute this program and study the results.
The observant student will notice that there is a slight
discrepancy in the results given in lines 79 through 81, since the
first two values do not a