UMBC CMSC202, Computer Science II, Spring 1998, Sections 0101, 0102, 0103, 0104 and Honors

Thursday April 9, 1998

Assigned Reading:

• A Book on C:
• Programming Abstractions in C:

Handouts (available on-line): none

Topics Covered:

• More discussion on Object-Oriented design.

• On class derivation and inheritance: in our previous example with linked lists, we saw how to reuse the code for linked lists by replacing the definition of the ListItem class. Another way to reuse our code is to extend a class through a process called class derivation. In this lecture, we return to our simple example of the Box class and see how the classes Cube and ColorCube can be derived from it. In the next lecture, we will show how stacks and queues can be derived from list. So, as you go over the derivation of Cube from Box, pretend that the implementation of Box includes very complicated member functions that you want to reuse instead of re-code.

• Our first task is to make some small changes to the Box class we defined previously.

  • 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 member function called debug() which prints out the shared private member count. It is not uncommon in developing C++ programs to have member functions whose only purpose is to print out the contents of private members. We would otherwise be unable to examine the values of private members even for debugging purposes.

  • 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 printf() statements in the constructors for debugging purposes. The main program and sample run show the use of the compare() function.

• Next, we derive a class called Cube from the Box class. The intuitive idea behind this derivation is that we want objects that are "cubes" --- boxes with equal sides. Instead of defining a completely new Cube class, we reuse the code from the Box class. In this situation, Cube is called the derived class and Box is called the base class. Members in the base class automatically become members in the derived class (except for constructors, destructors and the = operator); these members are called inherited members. In our example, Cube inherits (among others) the data members length, height and width. Note that we do not include the inherted members in Cube class declaration. (See header file and implementation of Cube.)

  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 = Cube(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 printf() 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 shared member count. Note that since the Box constructors are the only functions which modify the value of count, our calls to debug() prints out the total number of boxes, counting each cube 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 ; ... printf("\nGrow c1\n") ; c1.grow() ; Similarly, the public member functions volume(), shrink() and debug() are accessible through a cube object. However, random() is not, since it is private in Box --- in fact, random() is not even accessible from a Cube member function. Also, 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.

• In the last step, we derive a class called ColorCube from the Cube class. Again, we use a public derivation, so the public member functions in Box are accessible through a ColorCube object. And again, we think of a colored cube as a special case of cube. In this case, however, we add a new data member ccolor to store the color of the cube. (See header file and implementation of ColorCube.) A new member of a derived class is called an appendant member. The main program and sample run show how the ColorCube class is used.

  Notable points:

  • The ColorCube class has a member function identify(). This function overrides the identify() function in the Cube class.

  • When either 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.

  • 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. The alternate constructor for ColorCube is an example of this access; it modifies the values of length, height and width.

  • 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.