UMBC CMSC202, Computer Science II, Fall 1998, Sections 0101, 0102, 0103, 0104

17. More Class Derivation

Thursday October 29, 1998

Assigned Reading:  7.6-7.15

Handouts (available on-line):

Programs from this lecture:

• Array class from Lecture 14
• Derivations of the Array class
• GenQ class from Lecture 10
• Classes derived from GenQ

Topics Covered:

• Exam 2 topics

• In this lecture, we look at some more useful examples of public derivation. For derivation to work properly, the base class must have been designed with derivation in mind. For example, we want to extend the Array class used in Lecture 14. However, the data member size was declared as a private member of the Array class. This prevents us from defining constructors in a derived class that would modify the size of an array. Clearly, an undesirable situation. As a result, we are forced to redefine the Array class to make it more amenable to derivation. In the new declaration, the size data member is declared as a protected member. This allows us to declare an FAarray class that includes a constructor which makes an array from the contents of a file.

  • Implementation of the new Array class

  • Implementation of the FArray class

  • Test program demonstrating the use of the new member functions sort() and write() of the FArray class. See sample run.

  • Second test program demonstrating the use of the new "file" constructor and the new member function search the of FArray class. See sample run.
   

• Because an FArray object is also an Array object, functions written to take Array parameters can also take FArray parameters (e.g., the Merge Sort function). If we simply copied the declaration and implementation of the Array class and made a new FArray class without using class derivation, then the compiler would not know the relationship between Arrays and FArrays.

• We took a closer look at the GenQ class for generic queues from Lecture 10 and discusses some implementation details.

  • Original GenQ class declaration and implementation.

  • A test program demonstrating the use of the GenQ class to keep a queue of integers. Sample run.

  • Second test program demonstrating the use of the GenQ class to simultaneously keep a queue of integers and a queue of strings. Sample run.
   

• It is awkward to use the GenQ class. For example, to enqueue an integer, we must first dynamically allocate memory for the integer and pass a pointer to that location: L.enqueue(new int(5)) ; Dequeuing is also awkward. The dequeue() function returns a pointer to an integer. This memory must be deallocated each time.

• We can eliminate the awkwardness of the GenQ class by deriving easier-to-use, specialized classes from GenQ. However, we need to modify GenQ somewhat to make it amenable to derivation. Again, a bit of forethought would have made these changes unnecessary.
  New class declaration and implementation.

• Now it becomes relatively simple to derive an IntQ class for integer queues from GenQ:

  • IntQ class declaration and implementation.

  • Test program demonstrating the simpler interface of the IntQ class (compared to using GenQ directly). Even the constructor is simpler. Sample run.
   

• Similarly, we can derive a class for a queue of strings using the BString class from Lecture 9 and Lecture 10.

  • BStringQ class declaration and implementation.

  • Test program demonstrating the use of the BStringQ class. Sample run.