CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Read chapter 12 from C++ Primer Plus (2nd ed.), by Stephen Prata.

Inheritance in C++ (continued)

• (continued)
  • A circle is a point with an property radius, an additional function setRadius, and an overridden function display.
    An overridden function is a function in a derived class which replaces a function in a base class.

  • A disk is a circle which is coloured in. It contains an overridden function display.

  • We can draw a diagram to show how the classes are related.

  • Here is how we can implement this class hierarchy in C++.

       //  file graphobj.h
    
       #ifndef _graphobj_h_
       #define _graphobj_h_
    
       class Point {
          public:
    	 void move(float new_x, float new_y);
    	 void setColour(int new_colour);
    	 void display();
          protected:
    	 float x_coord;
    	 float y_coord;
    	 int   colour;
          }:
    
       class Circle : public Point {
          public:
    	 void display();
    	 void setRadius(float new_radius);
          protected:
    	 float radius;
          };
    
       class Disk : public Circle {
          public:
    	 void display();
          };
    
       #endif
    
    
       //  file graphobj.cpp
    
       #include "graphobj.h"
    
       void Point::move(float new_x, float new_y) {
          x_coord = new_x;
          y_coord = new_y;
       }
    
       void Point::setColour(int new_colour) {
          colour = new_colour;
       }
    
       void Point::display() {
          showpoint(x_coord, y_coord, colour);    //  Assume graphics function exists.
       }
    
       void Circle::display() {
          showcircle(x_coord, y_coord, colour, radius);    //  Assume graphics function exists.
       }
    
       void Circle::setRadius(float new_radius) {
          radius = new_radius;
       }
    
       void Disk::display() {
          Circle::display();
          fillarea(x_coord, y_coord, colour);    //  Assume graphics function exists.
       }
    	       

  • Here is an example which uses these C++ classes.

       #include "graphobj.h"
    
       int main() {
          Point  p;
          Circle c;
          Disk   d;
    
          p.move(1.0, 2.0);
          p.setColour(15).
          p.display();
    
          c.move(5.0, 3.0);
          c.setColour(12);
          c.setRadius(4.0);
          c.display();
    
          d.move(7.0, 4.0);
          d.setRadius(15.0);
          d.setColour(3);
          d.display();
    
          return 0;
       }
    	       

  • Note that we didn't need to write Circle::move or Disk::move or Disk::setRadius. These functions were inherited. Inheritance can save us a lot of time in writing and debugging code.

Constant Member Functions

• Constant member functions are member functions which do not change the instance for which they are called.

• They are indicated by putting the const keyword after the parameter list.
  • Example:

       class sentence { 
          public:
    	 int wordCount() const;
             ...
          private:
    	 int count;
    	 ...
          };
    
       ...
    
       int sentence::wordCount() const {
          return count;
       }
    	       

• A constant member function cannot call a non-constant member function, since this might change the instance.

• It is good practice to label member functions with const if they don't change the instance.

• A constant member function must have the const keyword in both the declaration and the definition.

Return to lecture notes index

Lectures