Inheritance: Deriving new classes using existing classes

Inheritance: Parent and Child classes

One of the powerful features in object oriented programming in inheritance
When we define a new class and this class is an extension of an existing class, the we can use the existing class to define the new class

Syntax:

class myOldClass { // Contains variables + functions ... } class myNewClass public : public myOldClass { // Inherits all variables and functions // in "myOldClass" new variables + new functions ... }

Example:

The old class:

class myOldClass { public: int i1; void func1(int i) { i1 = i1 + i; } };

The new class:

class myNewClass : public myOldClass { public: int i2; void func2(int i) { i2 = i2 - i; } };

The new class has the following member variables and functions:

int i1;
int i2;
void func1()
void func2()

It is as though we have defined myNewClass as follows:

class myNewClass { public: int i1; int i2; void func1(int i) { i1 = i1 + i; } void func2(int i) { i2 = i2 - i; } };

You can use any of the above members.

Example:

int main(int argc, char *argv[]) { myNewClass B; B.i1 = 0; B.i2 = 0; B.func1(1); cout << B.i1 << "\t" << B.i2 << "\n"; B.func2(9); cout << B.i1 << "\t" << B.i2 << "\n"; }

Example Program: (Demo inheritance)
- Prog file: click here

Terminology

The existing class myOldClass used to define a new class is called the parent class
The new class myNewClass is called the child class
(myOldClass is the parent class of myNewClass)
The mechanism to define a new class using an existing class is called inheritance

The parent class is also known as:
The child class is also known as:

Usages of the inheritance mechanism

The obvious use of the inheritance mechanism is program re-use: the inheritance mechanism allows programmers to include existing programs as base to write new programs.

Another practical usage of the inheritance mechanism that is less obvious is:

It provides the ability to change a function depending on the type of the variable (See: click here)

Vector Jacobi(Matrix P, Matrix Q, Vector b) { Vector v1, v2; int i; double d; for (i = 0; i < 3; i = i + 1) { v1.x[i] = 0; v2.x[i] = 1; } d = 0.1; while ( d > 0.0001 ) { v2 = P*v1 + Q*b; // Invokes: operator*() d = distance(v1, v2); v1 = v2; } return(v2); }

With the programming mechanism called polymorphism, we can change the function call operator*() depending on the type of the variable passed to the function.

DenseMatrix P1, Q1; Vector sol, b; sol = Jacobi( P1, Q1, b); --> operator*() will invoke the operator*() function in the DenseMatrix class

SparseMatrix P1, Q1; Vector sol, b; sol = Jacobi( P1, Q1, b); --> operator*() will invoke the operator*() function in the SparseMatrix class

Before we can understand how such program can be written, I need to discuss function polymorphism first.