chap09.txt

含有文章和源码

does follow a few simple rules.  The order of member initialization
does not follow the order given by the initialization list, but
another very strict order over which you have complete control.
All inherited classes are initialized first in the order they are
listed in the class header.  If lines 14 and 15 were reversed,
class new_date would still be initialized first because it is
mentioned first in line 8.  It has been mentioned that C++ respects
its elders and initializes its parents prior to itself.  That
should be a useful memory aid in the use of member initializers.

Next, all local class members are initialized in the order in which
they are declared in the class, not the order in which they are
declared in the initialization list.  Actually, it would probably
be good practice to not use the member initializer to initialize
class members but instead to initialize them in the normal
constructor code.

Finally, after the member initializers are all executed in the
proper order, the main body of the constructor is executed in the
normal manner.

USING THE NEW CLASS
_________________________________________________________________

The example program named USEDTTM.CPP uses the datetime class we
just built, and like our previous examples, the main program is

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

kept very simple and straight forward.  You will  ===============
note that the default constructor is used for       USEDTTM.CPP
the object named now, and the constructor with    ===============
the member initializers is used with the objects
named birthday and special.

The diligent student should have no trouble understanding the
remaining code in this example.


FUTURE DIRECTIONS OF C++
_________________________________________________________________

An ANSI committee has been formed to write an ANSI standard for
C++.  They first met in the Spring of 1990 and are expected to
complete the standard in about three years.  Until the new standard
is released, the C++ language is expected to stay fairly stable.
However, due to the nature of compiler writers and their desire to
slightly improve their offerings over their competitors, you can
bet that the language will not remain static during this three year
period.

Many small changes have been added during the past year that barely
affect the casual programmer, or even the heavy user of the
language.  You can be sure that the language will evolve slowly and
surely into a very usable and reliable language.  There are two
areas, however, that should be discussed in a little detail because
they will add so much to the language in future years.  Those two
topics are parameterized types and exception handling.



FUTURE DIRECTIONS - PARAMETERIZED TYPES
_________________________________________________________________

Many times, when developing a program, you wish to perform some
operation on more than one data type.  For example you may wish to
sort a list of integers, another list of floating point numbers,
and a list of alphabetic strings.  It seems silly to have to write
a separate sort function for each of the three types when all three
are sorted in the same logical way.  With parameterized types, you
will be able to write a single sort routine that is capable of
sorting all three of the lists.

This is already available in the Ada language as the generic
package or procedure.  Because it is available in Ada, there is a
software components industry that provides programmers with
prewritten and thoroughly debugged software routines that work with
many different types.  When this is generally available in C++,
there will be a components industry for C++ and precoded, debugged
and efficient source code will be available off the shelf to
perform many of the standard operations.  These operations will
include such things as sorts, queues, stacks, lists, etc.


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


Bjarne Stroustrup has announced that parameterized types, otherwise
known as templates or generics, will be available in a future
version of C++.  He has presented a paper with details of one way
to implement them, but this is only a suggestion, not a
specification.

Borland International has included templates in version 3.0 of
Borland C++, and hopefully their implementation will be very close
to the final definition of templates.
The next three example programs will illustrate the use of
templates with Borland's compiler, but may not work with other
compilers.


THE FIRST TEMPLATE
_________________________________________________________________

The example program named TEMPLAT1.CPP is the    ================
first example of the use of a template.  This      TEMPLAT1.CPP
program is so simple it seems silly to even      ================
bother with it but it will illustrate the use of
the parameterized type.

The template is given in lines 4 through 8 with the first line
indicating that it is a template with a single type to be replaced,
the type ANY_TYPE.  This type can be replaced by any type which can
be used in the comparison operation in line 7.  If you have defined
a class, and you have overloaded the operator ">", then this
template can be used with objects of your class.  Thus, you do not
have to write a maximum function for each type or class in your
program.

This function is included automatically for each type it is called
with in the program, and the code itself should be very easy to
understand.

The diligent student should realize that nearly the same effect can
be achieved through use of a macro, except that when a macro is
used, the strict type checking is not done.  Because of this and
because of the availability of the inline method capability in C++,
the use of macros is essentially non-existent by experienced C++
programmers.



A CLASS TEMPLATE
_________________________________________________________________

The example program named TEMPLAT2.CPP is a      ================
little more involved since it provides a           TEMPLAT2.CPP
template for an entire class rather than a       ================
single function.  The template code is given in
lines 6 through 16 and a little study will show

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

that this is an entire class definition.  The diligent student will
recognize that this is a very weak stack class since there is
nothing to prevent popping data from an empty stack, and there is
no indication of a full stack.  Our intent, however, is to
illustrate the use of the parameterized type and to do so using the
simplest class possible.

In the main program we create an object named int_stack in line 25
which will be a stack designed to store integers, and another
object named float_stack in line 26 which is designed to store
float type values.  In both cases, we enclose the type we desire
this object to work with in "<>" brackets, and the system creates
the object by first replacing all instances of ANY_TYPE with the
desired type, then creating the object of that type.  You will note
that any type can be used that has an assignment capability since
lines 13 and 14 use the assignment operator on the parameterized
type.

Even though the strings are all of differing lengths, we can even
use the stack to store a stack of strings if we only store a
pointer to the strings and not the entire string.  This is
illustrated in the object named string_stack declared in line 27
and used later in the program.

This program should be fairly easy for you to follow if you spend
a bit of time studying it.  You should compile and run it if you
have a compiler that will handle this new construct.



REUSING THE STACK CLASS
_________________________________________________________________

The program named TEMPLAT3.CPP uses the same     ================
class with the template as defined in the last     TEMPLAT3.CPP
program but in this case, it uses the date class ================
developed earlier as the stack members.  More
specifically, it uses a pointer to the date
class as the stack member.

Because class assignment is legal, you could also store the actual
class in the stack rather than just the pointer to it.  To do so
however, would be very inefficient since the entire class would be
copied into the stack each time it is pushed and the entire class
would be copied out again when it was popped.  Use of the pointer
is a little more general, so it was illustrated here for your
benefit.

All three of the previous programs can be compiled and executed if
you have a copy of Borland C++ version 3.0.  Other compilers may
not work with these programs since parameterized types are not yet
a part of the C++ specification.



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


FUTURE DIRECTIONS - EXCEPTION HANDLING
_________________________________________________________________

A future version of C++ will have some form of exception handling
to allow the programmer to trap errors and prevent the system from
completely shutting down when a fatal error occurs.  The Ada
language allows the programmer to trap any error that occurs, even
system errors, execute some recovery code, and continue on with the
program execution in a very well defined way.  Bjarne Stroustrup,
working in conjunction with the ANSI-C++ committee, has announced
that some form of exception handling will be implemented but he has
not stated what form it would take as of this writing.


WHAT SHOULD BE YOUR NEXT STEP?
_________________________________________________________________

Once again, we have reached a major milestone in C++ programming.
With the ability to use inheritance, you have nearly all of the
tools you need to effectively use the object oriented programming
techniques of C++ and you would do well to stop studying again and
begin programming.  The only topic left with C++ is virtual methods
which are used for dynamic binding or polymorphism.  This will be
covered in the next two chapters.  The vast majority of all
programming can be done without dynamic binding, and in attempting
to force it into every program, you could wind up with an
unreadable mess, so you should approach it slowly.



























                                                         Page 9-9