chap07.txt

含有文章和源码

                                          Chapter 7 - Inheritance

ANOTHER DERIVED CLASS
_________________________________________________________________

Examine the file named TRUCK.H for an example of  ===============
another class that uses the vehicle class and         TRUCK.H
adds to it.  Of course, it adds different things  ===============
to it because it will specialize in those things
that pertain to trucks.  In fact it adds two
more variables and three methods.  Once again, ignore the keyword
public following the colon in line 7 for a few minutes and we will
cover it in detail in the next chapter of this tutorial.  See
figure 7-2.

A very important point that must be made is that the car class and
the truck class have absolutely nothing to do with each other, they
only happen to be derived classes of the same base class or parent
class as it is sometimes called.

Note that both the car and the truck classes have methods named
passengers() but this causes no problems and is perfectly
acceptable.  If classes are related in some way, and they certainly
are if they are both derived classes of a common base class, you
would expect them to be doing somewhat similar things.  In this
situation there is a good possibility that a method name would be
repeated in both child classes.


THE TRUCK IMPLEMENTATION
_________________________________________________________________

Examine the file named TRUCK.CPP for the        =================
implementation of the truck class.  It has          TRUCK.CPP
nothing unusual included in it.                 =================

You should have no problem understanding this
implementation.  Your assignment at this point is to compile it in
preparation for our example program that uses all three of the
classes defined in this chapter.


USING ALL THREE CLASSES
_________________________________________________________________

Examine the example program named ALLVEHIC.CPP   ================
for an example that uses all three of the          ALLVEHIC.CPP
classes we have been discussing in this chapter. ================
It uses the parent class vehicle to declare
objects and also uses the two child classes to
declare objects.  This was done to illustrate that all three
classes can be used in a single program.

All three of the header files for the classes are included in lines
3 through 5 so the program can use the components of the classes.
Notice that the implementations of the three classes are not in

                                                         Page 7-5

                                          Chapter 7 - Inheritance

view here and do not need to be in view.  This allows the code to
be used without access to the source code for the actual
implementation of the class.  However, it should be clear that the
header file definition must be available.

In this example program, only one object of each class is declared
and used but as many as desired could be declared and used in order
to accomplish the programming task at hand.  You will notice how
clean and uncluttered the source code is for this program since the
classes were developed, debugged, and stored away previously, and
the interfaces were kept very simple.  There is nothing new here
so you should have no trouble understanding the operation of this
program.

Compiling and executing this program will take a bit of effort but
the process is not complicated.  The three classes and the main
program can be compiled in any order desired.  All four must be
compiled prior to linking the four resulting object (or binary)
files together.  Finally, you can execute the complete program.
Be sure you do the required steps to compile and execute this
program because the effective use of C++ will require you to
compile many separate files and link them together.  This is
because of the nature of the C++ language, but it should not be a
burden if a good "make" capability exists with your compiler.  If
you are using the Borland implementation of C++, the "project"
capability will make this a snap.


WHY THE #ifndef VEHICLE_H ?
_________________________________________________________________

We promised to return to the strange looking preprocessor directive
in lines 4, 5 and 17 in the VEHICLE.H file, and this is the time
for it.  When we define the derived class car, we are required to
supply it with the full definition of the interface to the vehicle
class since car is a derived class of vehicle and must know all
about its parent.  We do that by including the vehicle class into
the car class, and the car class can be compiled.  The vehicle
class must also be included in the header file of the truck class
for the same reason.

When we get to the main program, we must inform it of the details
of all three classes, so all three header files must be included
as is done in lines 3 through 5 of ALLVEHIC.CPP, but this leads to
a problem.  When the preprocessor gets to the car class, it
includes the vehicle class because it is listed in the car class
header file, but since the vehicle class was already included in
line 3 of ALLVEHIC.CPP, it is included twice and we attempt to
redefine the class vehicle.  Of course it is the same definition,
but the system doesn't care, it simply doesn't allow redefinition
of a class.  We allow the double inclusion of the file and at the
same time prevent the double inclusion of the class by building a
bridge around it using the word VEHICLE_H.  If the word is already
defined, the definition is skipped, but if the word is not defined,

                                                         Page 7-6

                                          Chapter 7 - Inheritance

the definition is included and the word is defined at that time.
The end result is the actual inclusion of the class only once, even
though the file is included more than once.  You should have no
trouble understanding the logic of the includes if you spend a
little time studying this program sequence.

Even though ANSI-C allows multiple definitions of entities,
provided the definitions are identical, C++ does not permit this.
The primary reason is because the compiler would have great
difficulty in knowing if it has already made a constructor call for
the redefined entity, if there is one.  A multiple constructor call
for a single object could cause great havoc, so C++ was defined to
prevent any multiple constructor calls by making it illegal to
redefine any entity.  This is not a problem in any practical
program.

The name VEHICLE_H was chosen as the word because it is the name
of the file, with the period replaced by the underline.  If the
name of the file is used systematically in all of your class
definitions, you cannot have a name clash because the filename of
every class must be unique.  It would be good for you to get into
the practice of building the optional skip around all of your
classes.  All class definition files in the remainder of this
tutorial will include this skip around to prevent multiple
inclusions and to be an example for you.  You should get into the
practice of adding the skip around to all of your class headers no
matter how trivial they may seem to be.



OUR FIRST PRACTICAL INHERITANCE
_________________________________________________________________

Continuing where we started in chapter 5, we      ===============
will inherit the date class into the file named      NEWDATE.H
NEWDATE.H and add a member variable and a new     ===============
method to the class.  Actually, this is not a
good way to add the day_of_year to the date
class since it is available in the structure returned from the
system call in the date class.  However, we are more interested in
illustrating inheritance in a practical example than we are in
developing a perfect class, so we will live with this inefficiency.
You will note that we add one variable and one method to create our
new class.

The program named NEWDATE.CPP contains the        ===============
implementation for the added method and should      NEWDATE.CPP
be simple for the student to understand.  This    ===============
class implementation uses the array days[] from
the date class implementation since it was
defined as a global variable there.  The method named
get_time_of_day() involves very simple logic but still adjusts for
leap years.


                                                         Page 7-7

                                          Chapter 7 - Inheritance

Finally, the example program named TRYNDATE.CPP  ================
will use the new class in a very simple way to     TRYNDATE.CPP
illustrate that the derived class is as easy to  ================
use as the base class and in fact the main
program has no way of knowing that it is using
a derived class.

You should compile and link this program to gain the experience of
doing so.  Remember that it will be necessary to link in the object
code for the original date class as well as the object code from
the newdate class and the main program.


PROGRAMMING EXERCISES
_________________________________________________________________


1.   Add another object of the vehicle class to ALLVEHIC.CPP named
     bicycle, and do some of the same operations as were done to
     the unicycle.  You will only need to recompile the main
     program and link all four files together to get an executable
     file, the three classes will not require recompilation.

2.   Add the optional skip around the header files of the classes
     named car and truck.  Then recompile all four files and relink
     them to get an executable file.

3.   Add a new method to the truck class to return the total weight
     of the truck plus its payload and add code to ALLVEHIC.CPP to
     read the value out and display it on the monitor.  This will
     require an addition to TRUCK.H, another addition to TRUCK.CPP,
     and of course the changes to the main program named
     ALLVEHIC.CPP.  The answer is given as three files named
     CH07_3A.H (TRUCK.H), CH07_3B.CPP (TRUCK.CPP) and the changed
     main program is found in CH07_3C.CPP in the answer directory
     on the distribution disk for this tutorial.

4.   Add a variable named sex of type char to the name class you
     developed in chapter 5 as well as methods to set and retrieve
     the value of this variable.  The only legal inputs are 'M' or
     'F'.  These additions should be done by inheriting the name
     class into the new class.













                                                         Page 7-8