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

Tuesday April 14, 1998

Assigned Reading:

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

Handouts (available on-line):

Topics Covered:

• A review of public derivations discussed in the previous lecture.

• In this lecture, we consider another kind of derivation, called a private derivation. (There is also a protected derivation, but we won't discuss it in detail.) As an example of private derivation, we will define a class called Package that is derived from our box class. Intuitively, think of a package as a cardboard box. We will allow a package to be placed inside another package using a member function called Store. If a package is stored inside another package, then the package inside must be smaller than the package outside. (This we can determine using the compare function.) The important part is that once we place a package inside another one, we do not want the package inside to grow or the package outside to shrink. Otherwise, the condition that packages are only stored inside larger packages is no longer true. Thus, we want to make sure that the member functions grow() and shrink() are not accessible through a package object. This can be achieved using a private derivation.

  In the header file for the Package class, we declare the Package class to be a private derivation of the Box class in the following line, using the keyword "private".

  class Package : private Box { /* private derivation of class Box */ The rest of the declaration includes two constructors and the public member functions identify(), Store(), empty() and content(). These are the only publicly acessible members of Package. Even though Package inherits all the members of Box, the public members (e.g. grow() and shrink()) are not accessible through a Package object. This has the intended effect.

  Other notable points about the package implementation:

  • The main program and sample run show how the Package class is used.

  • A second main program and sample run show that the compiler generates an error if you try to access the grow() function through a Package object.

  • The Store() function uses the compare() function to determine whether a package fits inside another package. In order to do so, the Store() function needs some mechanism to refer to the host object. (When we call p2.Store(&p1) in the main program, p2 is the host object for this particular call.) This is accomplished using the this pointer. Each member function has a local variable this which points to the host object. Thus the function call r = compare(*this, *item) ; has the intended effect of comparing the host object with the package given in as a parameter.

• The following table describes when an inherited member is accessible:

  Accessibility of an Inherited Member

  	In the base class, the inherited member is a:
  Access From	Public Member	Protected Member	Private Member
  Members & friends of a derived class	Yes	Yes	No
  Members & friends of a subsequently derived class	if previous derivations are public or protected	if previous derivations are public or protected	No
  Other functions, using a derived object	if derivation is public	No	No

• Stacks: A stack is a Last-In-First-Out (LIFO) data structure (imagine a stack of papers). When you use a stack, you are allowed to put things on top of a stack or take things off the top of a stack, but you are not allowed to insert or remove things from the middle of a stack. (By the way, the term "stack" here is the same as the term we used when we discussed how local variables are stored. And in this case, using the same term is actually appropriate.) A stack by itself is that interesting. However, stacks are useful as a part of many algorithms (e.g., Depth-First Search).

• In our example, we use a stack to keep track of a "to do" list. The operations supported by the stack ADT are:

  • Push() places an item on top of the stack.

  • Pop() removes an item from the top of the stack and returns the data in that item.

  • Top() returns the data in the top item of the stack without removing it.

  • IsEmpty() determines whether the stack contains any items.

  • Depth() returns the number of items in the stack.

  • Print() prints out the contents of the entire stack.
  There are many ways to implement a stack (e.g., an array or a linked list). In our case, we can easily derive a Stack class from our implementation of singly-linked lists. (See header file.) Since we want only the stack operations to be accessible, we use a private derivation. The implementation is trivial: Push() is essentially the Prepend() operation and Pop() simply deletes the first item. The main program and sample run show how the stack operations are used.

• Next lecture, we will quickly show that it is also easy to derive queues from linked lists.