Hi, my name is Joseph Guangsheng He. Welcome to this page.

This page is under heavy construction. I will cover some interest topic for OOP here.

Part I Abstract Base Classes and Pure Vrtual Functions

Some classes, e. g. class Shape, are not particularly useful by itself.

• Objects of type Shape are too general to be of interest.
• A general Shape has no well defined perimeter, area, or contained points.
• We implemented Shape::area(), Shape::perimeter(), and Shape::contains() as best as we could, but it would be nicer not to have to implement them at all.
• Class Shape is interesting only a base class for other classes, such as Circle and Rectangle.

  There would be no reason to define class Shape at all, it we did not intend to derive classes from it.

• Why not dispense with class Shape, and only define Circle a and Rectangle?
  1. The data members and non-virtual functions of class Shape allow us to avoid duplication of code.
     • Operations defined for all shapes, and implemented in the same way for each shape, may be coded just once.
  2. Even more importantly, virtual members on class Shape allow us to mplement polymorphism.
     • Although objects of type Shape are not useful, pointers (or references) of static type Shape * (or Shape &) are very useful.
     • These actual objects to which these pointers point (or deferences refer) will be circles or rectangles (not Shapes).
     • But whether they are circles or rectangles need not to be known until execution time, and may change even as the program runs.
     • We may very well write code like.

       Shape *S[3] = {

       new Circle (7, Point(0, 2)),

       new Rectangle(3, 6, Point(8, 4)),

       new Rectangle(2, 3, Point(0, 1))};

     • In deed, nuch of the power of object-oriented programming comes from code like this.

Our class Shape should have been declared to be an abtract base class.

• In general, for a class A, if it makes no sense to creat objects of type A, and if the class A is present only to serve as a base for derived classes, in order to implement, then class A shuld be declared to be an abstract bse class.

What is the effect of declaring class A an abstract base class?

1. We canot creat objects of A.
2. We can creat pointers or references to A.
   • How ever, the actual objects to which these pointers point (or refrences refer) must be of non-abstract class types devired from A.
   • In other words, a pointer or reference may have static type A* or A&, but may not have dynamic type A* or A&.
3. We may not need to supply definitions for some of the virtual functions of A.

   Suppose we declare Shape to be an abstract base class.

   Shape S; //Error

   Circle C; //OK

   Shape *ps1 = new Circle; // OK

   Shape *ps2 = new Shape; //Error

   Shape &S = C; //OK

   int f (Shape S); // Error

   int g (Shape &t) ; //OK, t will refer to a Circle or Rectangle.

   Shape h(int i); //Error.

   Shape &k (int i); //OK as long as the restrictions on ref return are met.

How do we declare a base class as abstract?

• We simply declare at least one of its virtual member functions to be a pure virtual function.
• A virtual member function may be designated as pre virtual by placing ' = 0 ' after its signature:

  virtual int f f( int a) const = 0;

• In the (exceeding unlikely) event that there is no existing function which is appropriate to declare pure virtual, we may creat an otherwise function for this purposed:

  virtual void dummy () = 0;

What is the effect of designating a virtual member function of a class A as pure virtual?

1. It makes A as abstract base class.
2. It means that the class A need not supply a definition for the virtual function ( and usually doesn't).
3. It means that every class directly derived from A must override the virtual member function.
   • There is one exception: if the derived class is itself abstract, it need not override the virtual functions.
   • In fact, if the derived class doesn't override the pure virtual function, the derived class becomes abstract itself.
   • This rule makes sense: there is no definition for the base class version, to be used if the function is not overridden.

For an abstract base class, which virtual function should be declared pure virtual? Which should not?

• If there is no way to implement the virtual functions sensibly for the abstract base class , then it probably should be pure virtual.
  • This way, we don't need to supply anartificial definitions, e.g., define Shape::perimeter () to return 0.
• Destructors should not normally be declared pure virtual.
  • Even for an abstract base class, the destructor needs an implementation (possibly trivial), since it will be invoked by derived class destructors.
• If the base class can implement the virtual function in a way that works for many (but not all) derived classes, then the member functinon should not be pure virtual.
  • That way, many of the derived classes will not need to override the virtual function.
  • For example, say class Shape defined a virtual function StraightBoundary ( ) which will tell us if the boundary is made up of straight liine segments.
    • Class Shape defines

      virtual bool straightBoundary ( ) const { return true; }

    • Class Circle overrides this as

      virtual bool straightBoundary ( ) const { return false; }

    • Class Rectangle (and future classes for triangles, hexagons, trapeziods, etc) will not need to override straightBoundary ( ).

If the base class virtual function can perform a portion of the computation common to all the derived class member functions that override it, then we might choose not to make the base class function pure virtual.

• Each overriding function could call the base class function using scope operator.
• For example,

  // Virtual, but not pure virtual.

  char *Shape::description ( ) const {

  ostrtream os ( desc, 100 ) ;

  os << colorStr[ clr ] << " " << name ( ) << " at " << posn << ends; return desc; }

  char *Circle::description ( ) const

  { shape::description ( ); ostrstream os ( desc, 100, os::app) ; os << " , radius = " << rad << ends; return desc;}