Introduction to Inheritance
Reusability is another
important feature of OOP. The mechanism of deriving a new class from an old one
is called inheritance. Inheritance allows a class to include the members of
other classes without repetition of members. There were three ways to inheritance
means, “public parts of super class remain public and protected parts of super
class remain protected.” Private Inheritance means “Public and Protected Parts
of Super Class remain Private in Sub-Class”. Protected
Inheritance means “Public and Protected Parts of Superclass remain protected in
Subclass”.
CONCEPT
OF INHERITANCE
Inheritance is a
concept which is the result of commonality between classes. Due to this
mechanism, we need not repeat the declaration as well as member functions in a
class if they are already present in another class. For example, consider the
classes namely “minister” and “prime minister”. Whatever information is present
in minister, the same will be present in prime minister also. Apart from that
there will be some extra information in class prime minister due to the extra
privileges enjoyed by him. Now, due to the mechanism of inheritance, it is
enough only to indicate that information which is a specific to prime minister
in its class. In addition, the class prime minister will inherit the
information of class minister.
Let us take the
classes, Employee and Manager. A Manager is an Employee with some additional
information. when we are declaring the classes Employee and Manager without
applying the concept of inheritance, they will look as follows:
class Employee
{
public:
char* name;
int age;
char* address;
int salary; char*department;
int id;
};
Now, the class
Manager is as follows:
Class Manager {
public:
char* name;
int age;
char* address;
intsalary; char*department;
int id;
employee* team_members; //He heads a group of
employees int level; // his position in hierarchy of the organisation
.
.
.
.
};
Now, without repeating the entire information of
class Employee in class Manager, we can declare the Manager class as follows:
class Manager:
Public Employee
{
public:
Employee*Team_members; int level;
.
.
.
.
The latest declaration of class Manager is the same
as that of its previous one, with the exception that we did not repeat the
information of class Employee explicitly. This is what is meant by the
Application of inheritance mechanism. Please note that in the above example,
Employee is called Base Class and Manager is called Derived Class.
Inheritance
Visibility Mode
Depending
on Access modifier used while inheritance, the availability of class members of
Super class in the sub class changes. It can either be private, protected or
public.
1) Public
Inheritance
This
is the most used inheritance mode. In this the protected member of super class
becomes protected members of sub class and public becomes public.
class Subclass :
public Superclass
2) Private
Inheritance
In
private mode, the protected and public members of super class become private
members of derived class.
class Subclass : Superclass // By default its private inheritance
3) Protected
Inheritance
In
protected mode, the public and protected members of Super class becomes
protected members of Sub class.
class subclass : protected
Superclass
SINGLE
INHERITANCE
In this Section, you
will learn the ways of deriving a class from single class. So, there will be
only one base class for the derived class.
Private
Inheritance
Consider the
following classes:
class A { /*......*/); class C: private A
{
/*
.
.
.
.
*/
}
All the public parts of
class A and all the protected parts of class A, become private members/parts of
the derived class C in class C. No private member of class A can be accessed by
class C. To do so, you need to write public or private functions in the Base
class. A public function can be accessed by any object, however, private
function can be used only within the class hierarchy that is class A and class
C and friends of these classes in the above cases.
Public
Inheritance
Consider
the following classes: class A{/*........*/};
class E: public
A
|
{
|
/*
|
|
|
|
:
|
|
|
|
:
|
|
|
};
|
:
|
|
|
|
|
Now, all the
public parts of class A become public in class E and protected part of
Protected
Inheritance
Consider the following
classes: class E: protected A
{ /*
.
.
.
*/
};
Now, all the
public and protected parts of class A become protected in class E.
No private member of class A can be accessed by
class E. Let us take a single example to demonstrate the inheritance of public
and private type in more details.
Example:
#include
<iostream.h>
class
Value
{
protected:
int val;
public:
void set_values (int a)
{
{
protected:
int val;
public:
void set_values (int a)
{
val=a;
}
};
};
class Cube: public Value
{
public:
int cube()
{
{
public:
int cube()
{
return (val*val*val);
}
};
};
int
main ()
{
Cube cub;
cub.set_values (5);
cout << "The Cube of 5 is::" << cub.cube() << endl;
return 0;
}
{
Cube cub;
cub.set_values (5);
cout << "The Cube of 5 is::" << cub.cube() << endl;
return 0;
}
Output:
The Cube of 5 is:: 125
MULTIPLE
INHERITANCE
A class can have
more than one direct base classes.
Consider the
following classes:
|
Class A {/*
|
.....*/};
|
|
Class B {/* .....
|
*/};
|
Class C : public
A, public B
{ /*
.
.
.
.
*/
};
This is called Multiple
Inheritance. If a class is having only one base class, then it is known as
single inheritance. In the case of Class C, other than the operations specified in it, the union of operations of classes A and B
can also be applied.
Example:
#include<iostream.h>
#include<conio.h>
class
student
{
protected:
int rno,m1,m2;
public:
void get()
{
cout<<"Enter the Roll no :";
cin>>rno;
cout<<"Enter the two marks :";
cin>>m1>>m2;
}
};
class
sports
{
protected:
int sm;
// sm = Sports mark
public:
void getsm()
{
cout<<"\nEnter the
sports mark :";
cin>>sm;
}
};
class
statement:public student,public sports
{
int tot,avg;
public:
void display()
{
tot=(m1+m2+sm);
avg=tot/3;
cout<<"\n\n\tRoll
No : "<<rno<<"\n\tTotal
: "<<tot;
cout<<"\n\tAverage
: "<<avg;
}
};
void
main()
{
clrscr();
statement obj;
obj.get();
obj.getsm();
obj.display();
getch();
}
Output:
Enter
the Roll no: 100
Enter
two marks
90
80
Enter
the Sports Mark: 90
Roll
No: 100
Total
: 260
Average:
86.66
