chap09.txt

含有文章和源码

                                                        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 some
of the expected future directions of the language.

Several companies have C++ compilers available in the marketplace,
and many others are sure to follow.  Because the example programs
in this tutorial are designed to be as generic as possible, most
should be compilable with any good quality C++ compiler provided
it follows the AT&T definition of version 2.1 or newer.  Many of
these examples will not work with earlier definitions because the
language was significantly changed with the version 2.1 update.

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
annually.  Please feel free to contact us for information on
updates to the Coronado Enterprises C++ tutorial.


MULTIPLE INHERITANCE
_________________________________________________________________

A major recent addition to the C++ language 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, however, have
expressed doubts as to the utility of multiple inheritance.  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 variable or 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 and Future Directions


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
with no difficulty.  However, if we attempt to send a message to

                                                         Page 9-2

           Chapter 9 - Multiple Inheritance and Future Directions

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 derived class.

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.  Qualification is not necessary in
line 68 since it is the method in the derived class and it will
take precedence over the other method names.  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 add up to the third value exactly.  This
is due to the limited precision of the float variable but should
cause no real problem.



                                                         Page 9-3

           Chapter 9 - Multiple Inheritance and Future Directions


DUPLICATED VARIABLE NAMES
_________________________________________________________________

If you will examine the example program named    ================
MULTINH3.CPP, you will notice that each base       MULTINH3.CPP
class has a variable with the same name.         ================

According to the rules of inheritance, an object
of the driven_truck class will have two variables with the same
name, weight.  This would be a problem if it weren't for the fact
that C++ has defined a method of accessing each one in a well
defined way.  You have probably guessed that we will use
qualification to access each variable.  Lines 38 and 45 illustrate
the use of the variables.  It may be obvious, but it should be
explicitly stated, that there is no reason that the subclass itself
cannot have a variable of the same name as those inherited from the
parent classes.  In order to access it, no qualification would be
required.

It should be apparent to you that once you understand single
inheritance, multiple inheritance is nothing more than an extension
of the same rules.  Of course, if you inherit two methods or
variables of the same name, you must use qualification to allow the
compiler to select the correct one.


PRACTICAL MULTIPLE INHERITANCE
_________________________________________________________________

Examine the example program named DATETIME.H     ================
for a practical example using multiple              DATETIME.H
inheritance.  You will notice that we are        ================
returning to our familiar date and time classes
from earlier chapters.

There is a good deal to be learned from this very short header file
since it is our first example of member initialization.  There are
two constructors for this class, the first being a very simple
constructor that does nothing in itself as is evident from an
examination of line 12.  This constuctor allows the constructors
to be executed for the classes new_date and time_of_day.  In both
cases a constructor will be executed that requires no parameters,
and such a constructor is available for each of these two classes.

The second constuctor is more interesting since it does not simply
use the default constructor, but instead passes some of the input
parameters to the inherited class constructors.  Following the
colon in line 13 are two member initializers which are used to
initialize members of this class.  Since the two parent classes are
inherited, they are also members of this class and can be
initialized as shown.  Each of the member initializers is actually
a call to a constructor of the parent classes and it should be
evident that there must be a constructor with the proper number of

                                                         Page 9-4

           Chapter 9 - Multiple Inheritance and Future Directions

input parameters to respond to the messages given.  You will note
that in line 14, we are actually calling the constructor with no
parameters given explicitly.  If we chose, we could simply let the
system call that constructor automatically, but this gives us an
explicit comment on what is happening.


MORE ABOUT MEMBER INITIALIZERS
_________________________________________________________________

Actually, we can use the member initializer to initialize class
members also.  If we had a class member of type int named
member_var, we could initialize it also by mentioning the name of
the member followed by the value we desired to initialize it to in
parentheses.  If we wished to initialize it to the value 13, we
could use the following line of code in the member initializer
list;

   member_var(13);

Following all member initialization, the normal constructor code
is executed which in this case is given in line 16.


ORDER OF MEMBER INITIALIZATION
_________________________________________________________________

The order of member initialization may seem a bit strange, but it