Class Hierarchy In Object Oriented Programming Computer Science Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

One of the corner stone's of object-oriented programming is inheritance because it creates a different classifications of hierarchical. To make unique the few other specific classes whenever the class is inherited. Super class is called whenever a class in inherited. And the class which is not inherited is named as sub class. Her it is clear that sub class will appear by super class means specialised version. In this type of version its add unique elements whenever an methods and instance variables re inherited.

Example of class hierarchy

Inheritance basics

To inherit a class you simply incorporate the definition of one class into another.

 The constructor and destructor of a base class are not inherited the assignment operator is not C++ classes can inherit both data and function members from other classes.

 Some of the exceptions to be noted in C++ inheritance are inherited functions and friend classes of the base class are also not inherited.

The protected and public variables or members of the super class are all accessible in the derived class. But a private member variable not accessible by a sub class.

   The protected and private members will not accessible outside the class. But a sub class is given access to protected members of the super class.

   Exceptions to be noted by C++ inheritance

The non inherited base classes are constructor and destructor

Assignment operator

Friend classes and functions

We have notations to be remembered that in derived class accessible by a base class like members or public/protected variables. But in derived class private member variable will not accessible. Base classes which are declared to be virtual; this is called virtual inheritance. Inheritance graph exists base class that ensures only one instance avoid some ambiguity problems of multiple inheritance. This type of inheritance will not found in most the other languages, which allow derived class more than one base classes and also allow more elaborate inheritance relationships. In derived class, abstract base class normally explicit defined by member functions and not inherited implicitly.

Multiple inheritance

Public inheritance

Public syntax:

class Car : public Vehicle {




Types of Inheritances

Single inheritance

Syntax: class classname2




Class classname3: public classname2




Multiple inheritance

Syntax: class classname1




Class classname2: public classname1




Class classname3: public classname2




Hierarchal inheritance

Syntax: class classname1




Class classname2




Class classname3: public classname1,public classname2




Multi level inheritance

Hybrid inheritance


Virtual function

In case the sub class needs some different functionality for the same functions start stop and run then the super class should implement the concept of virtual functions.

At the time of compilation, the definition that gives a correct function call by default i should match in c++ is named as static binding. And same for dynamic binding but it will find a correct function call at the time of running(run time). Declaration is given by virtual keyword and there is a specific function that dynamic binding will use at the time of compilation.

Problems which solves by the concept of the virtual function:

Whenever a base class is inherited by a derived class, then derived class objects are referred to as derived class type or base type class. If base class overridden by derived class, then the method is ambiguous behavior. This resolves ambiguity by distinguishing non virtual and virtual functions. Functioning of question is designated, derived is called next after base class is called this is in virtual functioning and its reciprocal in non virtual functioning, base is called after derived class is called. This type is called static binding and dynamic binding.

The problems in virtual functioning can be solved by defining programmer firstly declaring functions into base class and then redefined in each derived class. In C++ virtual functions and methods are declared by virtual keywords.


At run time function call can be resolved.

Usually in this derived class different functionality are appeared

The functions are declared with virtual keyword

It is a class member function.

All the time base class function will be called whenever an function is not declared virtual. During the compile time the function address bound will be statically found. Now function is declared as virtual then he candidate for derived class and run time linking will be invoked.

Abstract class

Abstract class which is designed is specifically used as a base class. It should contain at least one virtual function. A pure virtual function is declare by using a pure specifier (=0).If any class contains at least one abstract function, then such a class is called abstract class.


abstract class classname


Member variables


Concrete methods


Abstract methods


An abstract class can have any know of implemented methods and abstract methods. Reference variable of type abstract class can be created but object of type abstract cannot be created. Every abstract class requires subclass. Sub class can inherit all the properties of abstract base class including dummy methods (abstract methods) so from the sub class we must override the abstract methods which are inherited, otherwise derived class becomes abstract class.


Poly stands for many and morphism stands for forms

Polymorphism= many terms.

It any function behaves differently within the same class or different classes such a behavior is known as polymorphism


Compile time Runtime

Dynamic binding

Function operator +

Overloading overloading Abstract methods or virtual methods


Default access specifier for this class is private

Property is the member of a class which is used to write the data into the data field or read the data from data field

For the single function or an operator function in different ways must depend up on the proper usage of the function.

Different sub classes should be derived from only single super class

For an example

Consider vehicle as the super class that is only super class

And vehicles tiers and engine are considered as sub class which is many

And derived from only one super class.

The member function should be declared virtually in the super class

From the above example the member functions of super class that is vehicle must be made virtual


If the program is written with the polymorphism concept then we extend the application easily

There is no need of recompiling the original application but only the relinking is required to have the new changes with the original application

Polymorphism helps in reusability of the code

Using polymorphism applications can be maintained in an easier manner.

Polymorphism helps in achieving robustness in the application

Different kinds of polymorphism

virtual functions

overloading of function name

overloading of operators

Other than these polymorphisms we have other polymorphism

Run time

Time of compilation

Polymorphism Ad-hoc

Polymorphism at run time:

These inheritance and virtual functions are implemented

Compile time polymorphism:

This is implemented with templates.

Ad-hoc polymorphism:

Standard Template Library

In C++ we have a standard fundamental part i.e. Standard template library. STL provides a standard implemented facilities and tools that are used in many applications.

STL is C++ library which contains of

Container classes



These provide many data structures and basic algorithms in computer science. Almost every STL components are heavily parameterised in a generic library. We have know about templates before working with STL.

Classification of STL components

Six STL components are below:




Function objects



This STL document having two indices one is main index and other is divided index these indexes are listing in an alphabetical order and each having their own priority. STL here explains about adaptor which is not included in the above.

Adaptor is a transformation of one interface into another interface. The reason why adaptor is included is it will considered in a stack.

 These components are classified in multiple ways.

These components are named as categories. This is a function classification:




Function Object




Next one is classification by structures:

Type (i.e. a struct or class)



These multi categories are applied to each and every STL component and these schemes were not related to each other just like independent. For the STL component document at top of page these categories are applied. These two categories are applied one at left corner and other is at right corner. But these will always be applied upper side itself. First category to left side and second category to right side.

Divided index


A collection of other objects (its elements) is stored in a container. These collection of objects are implemented as class templates these allows a great flexibility with the types supported in the elements. The container will manages the storage space for its elements and gives a member function to access them either through iterators or directly. Containers replicate structures very commonly used in programming:

dynamic arrays (vector),

queues (queue),

stacks (stack),

heaps (priority queue),

associative arrays

Many shared functionalities and member functions are used by containers. The container classes consist of other objects. It allows memory for elements to access them indirectly/directly by member functions. These classes are implemented with class templates. Containers are of 2 types:

Sequence container

Vector container

Vector is simple form compared to sequence containers. A vector is implemented in dynamic array by its elements. The accessing of elements is done with corresponding index any element can support by vector. In vector arrays allocation of memory is automatic. To hold elements some amount of memory is created by vector container. If we insert elements more than the memory then it automatically increase the memory. It will adds or removes the elements in the memory at the end.


Iterator is an object in C++ which pointing to elements in a range of elements which has ability through the elements range using a set of operators like dereference operator (*) and increment operator (++). The pointer is the most obvious iterator form in C++, this pointer can point out any array and can iterate them by using an increment operator (++). There is another form of iterate exists i.e. container type such as a vector. This has an iterator type which has a designed iterate through which the elements are iterated by efficient way. Notice that while a pointer is a form of iterator, then all iterators will not have the same functionality a pointer has;

To distinguish them we are divided them into five categories:

The above five are the iterator categories which are used in the functioning of iterators.

Random access





The most limited type iterators are input and output, these are specialised iterators used in performing input and output sequential operations.

By the range of iterate they are limited to one direction which are having functionality of input and output iterator is named as forward iterators.

An iterator is implemented through both directions is named as bidirectional iterator. The iterator of all standard containers will support at least bidirectional iterator types.


A header function is used to design on range of elements is named as algorithm. A sequence of objects range which can be accessed through pointers / iterators, such as an array or instance of some standard container. Containers will work with algorithms. In these container operations like sorting, merging, transformation, searching for contents present in the algorithm. These are present in the linear list and operate in a sequential manner.

Search: it will search in sequential manner.

Transform: which applies to range of elements.

Function objects

The functions whose syntax are similarly designed specially by function objects. In C++, this is achieved by defining member function operator() in their class, like for example:


struct myclass {

int operator()(int a) {return a;}

} myobject;

int x = myobject (0);

In standard algorithms, the function object is used as predicate and comparison functions. For many function objects standard library provides standard definitions and in some ways to modify and adapt their behaviour in header <functional>:


In C++ standard library utility will be used as header file. This header file has two main keys they are

​rel_ops​, It is a relational operators(​!=​, â€‹>​, â€‹<=​, and â€‹>=​ ) which sets a default behaviour containing a set of templates between objects of same type, it will based on user defined operators == and <​.

​pair, The two members objects are hold by a container template(1st and 2nd ) of arbitrary types. Additionally, the header defines default relational operators for pair​s which have both types in common.


In standard library the classes that defines the memory models which are used by some parts where allocator are classes, and most specifically by STL containers.

An allocator will be defined by following types:

Pointer to type

Const pointer to type

Reference to type

Const reference to type

These types will specify the allocated elements which forms a pointers and references.


template < class T > class allocator;