Understanding Abstract Classes and Multiple Inheritance: An Example with C++ | Study notes Object Oriented Programming

Chapter 16: Abstract Classes and Multiple Inheritance

From the Holy Bible, New King James Version, Proverbs 22:6.

Train up a child in the way he should go, and when he is old he will not depart from it.

An abstract class declares a set of behaviors (function prototypes) that all of its descendents must follow (or

implement). Documentation accompanying the abstract class must explain the purpose of each function and

how each interacts with other parts of the class. Derived classes must implement all of the functions, and should

obey the guidelines explained in the documentation.

16.1 An Abstract Class Defines Expectations

Abstract classes. When a base class includes even one prototype for a pure virtual function, it is an abstract

class which cannot be used to create objects. However, such classes do have a purpose and they are important

in the process of developing a large system. An abstract class lets us define and enforce a common interface, or

behavior, for a set of related classes. Class derivation, combined with methods defined in the derived class(es)

make the abstraction useful.

An abstract class specifies a set of virtual representation-dependent function prototypes for which definitions

will be required in future derived classes. By doing so, it enables a large system to be developed in a top-down

style.

The first development step is to define the major modules. The interface that each module provides is then

written The compiler will ensure that no necessary part of A is forgotten, and that all functions conform to the

prototypes that were promised.

Large systems developed by teams of programmers are built this way. First, each major system component

is identified. As soon as its role in the system is clear, its public interface can be defined in the form of an

abstract class declaration. The abstract class forms a contract for the programming team that will develop the

component, and different people (or teams) will work on different subsystems simultaneously.

Suppose a system designer has specified modules named A, B, and C. Since all the prototypes provided

by module A are defined, programmers working on modules B and C can begin to write code that calls the

functions of A, even before A is fully implemented. Derivation is used to connect the abstract interfaces to their

implementation modules. When modules are complete, the subsystems can be easily integrated because the

established prototypes guarantee that functions in one module will be able to call functions in another module

that were programmed by a different person.

Definitions and rules.

•The opposite of abstract is concrete. A concrete class can have virtual functions, but all of those functions

must have methods defined within the class itself or its ancestor classes.

•An abstract class cannot be instantiated, that is, used to construct any objects.

•Any class that has one or more pure virtual functions is called an abstract class.

•Abstract classes is polymorphic if more than one concrete class is derived from it.

16.2 Abstraction Example: an Ordered Type

Two abstract classes are used in this chapter’s program: Container (from the previous chapter) and Ordered.

•Container defines the interface that should be presented by any container class: a way to put data into

the container (put()), and find it when needed (get()), take it out of the container (remove()), write the

contents of the container to a stream (print()).

199

Understanding Abstract Classes and Multiple Inheritance: An Example with C++, Study notes of Object Oriented Programming

Related documents

Partial preview of the text

Download Understanding Abstract Classes and Multiple Inheritance: An Example with C++ and more Study notes Object Oriented Programming in PDF only on Docsity!

Chapter 16: Abstract Classes and Multiple Inheritance

From the Holy Bible, New King James Version, Proverbs 22:6.

Train up a child in the way he should go, and when he is old he will not depart from it.

An abstract class declares a set of behaviors (function prototypes) that all of its descendents must follow (or

implement). Documentation accompanying the abstract class must explain the purpose of each function and

how each interacts with other parts of the class. Derived classes must implement all of the functions, and should

obey the guidelines explained in the documentation.

16.1 An Abstract Class Defines Expectations

Abstract classes. When a base class includes even one prototype for a pure virtual function, it is an abstract

class which cannot be used to create objects. However, such classes do have a purpose and they are important

in the process of developing a large system. An abstract class lets us define and enforce a common interface, or

behavior, for a set of related classes. Class derivation, combined with methods defined in the derived class(es)

make the abstraction useful.

An abstract class specifies a set of virtual representation-dependent function prototypes for which definitions

will be required in future derived classes. By doing so, it enables a large system to be developed in a top-down

style.

The first development step is to define the major modules. The interface that each module provides is then

written The compiler will ensure that no necessary part of A is forgotten, and that all functions conform to the

prototypes that were promised.

Large systems developed by teams of programmers are built this way. First, each major system component

is identified. As soon as its role in the system is clear, its public interface can be defined in the form of an

abstract class declaration. The abstract class forms a contract for the programming team that will develop the

component, and different people (or teams) will work on different subsystems simultaneously.

Suppose a system designer has specified modules named A, B, and C. Since all the prototypes provided

by module A are defined, programmers working on modules B and C can begin to write code that calls the

functions of A, even before A is fully implemented. Derivation is used to connect the abstract interfaces to their

implementation modules. When modules are complete, the subsystems can be easily integrated because the

established prototypes guarantee that functions in one module will be able to call functions in another module

that were programmed by a different person.

Definitions and rules.

must have methods defined within the class itself or its ancestor classes.

16.2 Abstraction Example: an Ordered Type

Two abstract classes are used in this chapter’s program: Container (from the previous chapter) and Ordered.

the container (put()), and find it when needed (get()), take it out of the container (remove()), write the

contents of the container to a stream (print()).

200 CHAPTER 16. ABSTRACT CLASSES AND MULTIPLE INHERITANCE

sentinels, and a way to access the key field of the data.

Specifying and enforcing requirements. The purpose of a container is to store a collection of items. The

data stored in an item is not important; we use the class name Item as a representative of any kind of object

that a containers might store. However, a few properties of an Item are essential for use with a sorted container:

of these operators. They will be stored in the container in ascending order, as defined by the operator <.

appropriate definitions for the operators and sentinels that define the minimum and maximum possible

values for a KeyType object.

The first two properties can be specified by defining an abstract class, Ordered, that gives prototypes (but no

definitions) for the three required functions. We can enforce these requirements in a data class by deriving the

data class from Ordered. When we do this, we instruct the compiler to guarantee that the derived data class

does implement every function listed by Ordered. If one of the functions is missing, the compiler will give an

error comment.

A class may be derived from more than one parent class. (We must #include the header files for each parent

class.) The purpose of such multiple inheritance is:

The syntax is a simple extension of ordinary derivation. We use it here (line 30) to combine the properties

of the Exam class from the previous chapter with the abstract Ordered class. The new class is a wrapper for

Exam that provides more functions than the original class but does not duplicate the ones that Exam supplies

(Print() and operator<<).

In the previous chapter, we used a typedef to make Item a synonym for the Exam class. In this chapter, we do

more with Item: we use multiple inheritance to add constraints and functionality to the original Exam class.

202 CHAPTER 16. ABSTRACT CLASSES AND MULTIPLE INHERITANCE

normally. This class will be used with Linear and Cell from the prior chapter to build two new container classes:

List and Priority Queue.

In this chapter we develop two new container classes from Linear. In a stack or a queue, all insertions and

deletions are at one of the ends of the container; we never need to locate a spot in the middle. In contrast, a

priority queue requires all insertions to be made in sorted order, and a simple list requires a search whenever

an item is removed. To develop these classes in a general way, we assume that each Cell will contain an Item

that is derived from Ordered, and we use the functions promised by Ordered to define three new functions in

the Linear class:

bool Linear:: operator < ( Cell* cp ) { return (*cp->data < *here->data); }

bool Linear:: operator < ( KeyType k ){ return *here->data < k; }

bool Linear:: operator== ( KeyType k ){ return *here->data == k; }

These functions allow us to search or sort a linear container according to the key field of the Item.

Notes on the PQueue code Items are deleted from a priority queue at the head of the list, just like an

ordinary queue. Preparation for a deletion is easy because Linear provides the reset() function to position its

pointers at the head of the list.

In a priority queue, items are inserted in priority order in the list and removed from the head of the list.

To do the insertion, we must scan the list to locate the correct insertion spot: the item at prior should have

higher priority (a higher key number than the new item) and the item at here the same or lower priority. The

loop on lines 60–62 performs such a scan using the < operator and list traversal functions (reset(), end(), and

bool Linear:: operator < ( Cell* cp ) { return (cp->data < here->data); }