- We use the fstream member function write() to store a sorted
array of floating numbers in a "binary" file. This is more efficient in
terms of time and space when compared to storing the floating point numbers
as text. Program and sample runs.
- The file of floating point numbers can be copied into an array using
the read() member function of the fstream class. We do this in
the main functions of our linear search
program and binary search program.
- Sample runs of linear search
versus sample runs of binary search
show that binary search is much faster.
- The Array class we are using is awkward, because functions to sort and search in the array should be member functions. Also, functions for storing the array in a file and creating an array from a file should be member functions. We could rewrite the Array class to accomplish this. Then, the program to store a sorted file and the program to test binary search would be much simpler. (See sample runs for the first program and the second program.)
- In the new declaration of the Box class (see header file), we moved three members
length, height and width from the private
section to a new protected section. (We will soon discuss the purpose of
the protected section.) We also added a new static member function called
report() which prints out the values of the static members
count and sequence. (These static members serve the same
purpose as in the Widget class from Lecture
5.)
- The second change we made in the declaration of the Box class is to
designate the function compare() to be a friend of the Box class.
This allows the compare() function to have access to all the
private and protected members of the Box class. The compare function
determines whether a box fits inside another box by comparing the
length, height and width members of the two
boxes. An alternative is to make compare() a member function of
the Box class.
- The implementation of the new Box
class is straightforward. We include print statements in the constructors
and destructor for debugging purposes. The main program and sample run show the use of the
compare() function.
- Note the use of the member initializers in the alternate constructor
of the Box class
Box::Box(float len, float ht, float wd) : length(len), height(ht), width(wd) // member initializers { // ... body of the constructor ... } Member initializers can be used to set the value of the data members in a class prior to the execution of the body of a constructor. Of course, we could also simply assign values to these data members in the body of the constructor. However, when a data member is a const member or a reference, we must use a member initializer to initialize the value of the data member (q.v. Section 5.3 of your textbook).
Other important points regarding this derivation are:
- We need to declare and implement constructors for Cube. In fact, we
have two constructors. The alternate constructor takes as argument the
length of the side of the cube being constructed. When a new cube is
constructed, the default constructor of Box is called first. In the main program which uses the Cube
class, we define two cubes in the statements:
Cube c1 ; // use default constructor Cube c2(1.2) ; // use alternate constructor Observe that in the sample run, the default constructor for the Box class prints out the first line of the output. This is followed by the output from the print statement in the Cube constructors. Also note that even when the alternate Cube constructor is called, the default Box constructor is the one called, not the alternate Box constructor.
- Both the Cube class and the Box class have a member function called
identify(). In this case, the member function in the derived
class overrides the function in the Box class with the same name.
This is desirable in our example because we want cubes to identify
themselves differently. The sample
run shows that cubes identify themselves by "I'm a cube ..." and boxes
say "I am a box ...". (Excuse the anthropomorphism, but we want to think
of objects as autonomous entities.)
- The compare() function can be used with cubes even though it
was originally defined and implemented for boxes. This example illustrates
the utility of derivations. Since cubes are simply special cases of boxes,
comparing cubes is not any different from comparing boxes. Since the
compare() function is a friend of the Box class, it has access to
the length, height and width inherited members
of a cube. Also note that we can use the compare() function to
compare a box with a cube.
- The member functions of the Cube class have access to the
length, height and width inherited members,
because these members are protected instead of private in the Box class. If
the members were private, then the Cube constructor would not be able to
alter the values of these fields. For example, member functions of Cube
cannot change the value of the private member serial_number. The
Cube identify() function prints out the cube's serial number by
invoking the protected Box member function serial().
- Note that the Box constructors are the only functions which modify the
value of count, sequence and serial_number. Our
calls to report() prints out the total number of boxes in
existence and the total number of boxes ever made. In this scheme, each
cube counts as a box.
- This derivation is called a public derivation because the
keyword public appears before the name of the base class in the declaration
of the derived class in the header file:
class Cube : public Box { // public derivation of class Box ... In a public derivation, the public members of the base class are accessible through a derived object. What does this mean? It means that we can use the function grow() declared in the Box class to grow a cube, using the syntax:Cube c1 ; ... cout << "\nGrow c1" << endl ; c1.grow() ; Similarly, the public member functions volume(), shrink() and report() are accessible through a cube object. However, the protected members of Box length, height and width are still inaccessible from non-member functions (except from friend functions). - Note that the Cube constructors initialize the sides of a cube with equal values. Also the functions grow() and shrink() change the length of each side by the same factor. Since these are the only functions that can alter the values of length, height and width, we can guarantee that we never have a cube that has unequal sides. This example demonstrates a nice feature of OOP --- we have a mechanism for ensuring that objects only have "sensible" values.
Notable points:
- The ColorCube class has a member function identify(). This
function overrides the identify() function in the Cube class.
- When the default ColorCube constructor is called, the default Box
constructor and the default Cube constructor are called first and in that
order. Thus, all we have to do in the default ColorCube constructor is to
set a default value for the color of the cube stored in the member
ccolor.
- In the alternate ColorCube constructor, we want to invoke the
alternate Cube constructor instead of the default Cube constructor. To
accomplish this, we use the member initializer as follows:
ColorCube::ColorCube(float side, color c) : Cube(side) { // ... body of constructor ... } The alternate Cube constructor is invoked here with the parameter side. If there is more than one alternate constructor, the normal rules for resolving overloaded functions apply. - Because the Cube and the ColorCube derivations are public derivations,
the member functions in ColorCube can modify values of protected members in
the Box base class.
- As with the Cube class, we can use the Box member functions grow(), shrink() and volume() through a ColorCube object. We can also use the compare function to compare any two objects of type Box, Cube or ColorCube.