Inheritance in C++

Inheritance
• The existing classes are the main components of inheritance. The
new classes are created from existing ones. The properties of the
existing classes are simply extended to the new classes. The new
classes created by using such a method are known as derived
classes, and the existing classes are known as base classes.
• The relationship between the base and derived classes is known
as kind of relationship. The programmer can define new member
variables and functions in the derived class. The base class
remains unchanged. The object of the derived class can access
members of the base as well as derived classes. On the other
hand, the object of the base class cannot access members of the
derived classes. The base class does not know about their
subclasses.
1

REUSABILITY
Reusability means the reuse of properties of the base class in the
derived classes. Reusability permits the reuse of members of the
previous class. We can add extra features in the existing class. This
is possible by creating a new class from the existing class. The new
class will have the features of both the old and the derived new
class. Reusability is achieved using inheritance. Inheritance and
reusability are not different from each other. The outcome of
inheritance is reusability. Reusability is achieved using inheritance.
Inheritance and reusability are not different from each other. The
outcome of inheritance is reusability.
The base class is also called superclass, parent, or ancestor, and the
derived class is called subclass, child, or descendent. It is also
possible to derive a class from a previously derived class. A class
can be derived from more than one class.
2

ACCESS SPECIFIERS AND SIMPLE INHERITANCE
The public members of a class can be accessed by an object directly outside the
class. Directly means when objects access the data member without the member
function of the class. The private members of the class can only be accessed by the
public member function of the same class. The protected access specifier is the
same as private. The only difference is that it allows its derived classes to access
the protected members directly without the member functions.
The General syntax is
class name of the derived class: access specifiers - name of the base class
{
_____________ __
___________ // member variables of new class (derived class)
_____________ __
}
The names of the derived and base classes are separated by a colon (:). The access
specifiers may be private or public. The keyword private or public is specified
followed by a colon. Generally, the access specifier is to be specified. In the
absence of an access specifier, the default is private. The access specifiers decide
whether the characteristics of the base class are derived privately or publicly. The
derived class also has its own set of member variables and functions. 3

class B: public A
{
// Members of class B
};
In the above syntax, class A is a base class, and class B is a derived class. Here, the class B is
derived publicly.
class B: private A // private derivation
{
// members of class B
};
class B: A // by default private derivation
{
};
class B: protected A // same as private
{
};
4

In the above syntaxes, the class B is derived privately from the base class A. If no
access specifier is given, the default mode is private. The use of protected access
specifier is the same as private access.
It is important to note the following points:
– When a public access specifier is used (example 1), the public members of the
base class are public members of the derived class. Similarly, the protected
members of the base class are protected members of the derived class.
– When a private access specifier is used, the public and protected members of
the base class are the private members of the derived class.
5

Public Inheritance
• The class can be derived either publicly or privately. No third type exists. When a
class is derived publicly, all the public members of the base class can be accessed
directly in the derived class. However, in private derivation, an object of the
derived class has no permission to directly access even public members of the base
class. In such a case, the public members of the base class can be accessed using
public member functions of the derived class.
• In case the base class has private member variables and a class derived publicly,
the derived class can access the member variables of the base class using only
member functions of the base class. The public derivation does not allow the
derived class to access the private member variable of the class directly as is
possible for public member variables.
6

Write a program to derive a class publicly from base class. Declare the base class with
its member under public section.
#include<iostream.h>
#include<constream.h>
class A { // BASE CLASS
Public:int x; };
class B: public A { // DERIVED CLASS
Public: int y; };
int main() {
clrscr();
B b; // DECLARATION OF OBJECT
b.x=20;
b.y=30;
cout<<“n member of A:”<<b.x;
cout<<“n Member of B:”<<b.y;
return 0; }
OUTPUT
Member of A : 20
Member of B : 30
8

Write a program to derive a class publicly from base class. Declare the base class member
under private section.
Private: int x;
Public: A() {x=20;}
void showx() {
cout<<“n x=”<<x; } };
class B : public A { // DERIVED CLASS
Public: int y;
B() {y=30;}
void show() {
showx();
cout<<“n y=”<<y; } };
9

int main()
{
clrscr();
b.show();
return 0;
}
In the above program, the class B is derived privately from the class A. The member
variable x is a public member of the base class. However, the object b of the derived
class cannot directly access the variable x. The following statements are invalid:
b.x=30; // cannot access
The class B is derived privately. Hence, its access is restricted. The member function of the
derived class can access the members of the base class. The function show() does the
same.
10

PROTECTED DATA WITH PRIVATE INHERITANCE
• The member function of the derived class cannot access the private member variables
of the base class. The private members of the base class can be accessed using the
public member function of the same class.
• This approach makes the program lengthy. To overcome the problems associated with
private data, the creator of C++ introduced another access specifier protected. The
protected is similar to private, but it allows the derived class to access the private
members directly.
Write a program to declare protected data in base class. Access data of base class declared
under Protected section using member functions of derived class.
protected: int x; }; // protected declaration
class B : private A { // DERIVED CLASS
Private : int y;
Public: B() {
x=30;
y=40; }
11

void show()
{
cout<<“n x=”<<x;
cout<<“n y=”<<y;
}
};
int main()
{
clrscr();
b.show();
return 0;
}
OUTPUT
x=30
y=40
12

Inheritance is classified as follows:
• Single Inheritance
• Multiple Inheritance
• Hierarchical Inheritance
• Multilevel Inheritance
• Hybrid Inheritance
• Multi-path Inheritance
Single Inheritance
• This occurs when only one base class is used for the derivation of a derived class.
Further, derived class is not used as a base class, such a type of inheritance that
has one base and derived class is known as single inheritance.
Multiple Inheritance
• When two or more base classes are used for the derivation of a class, it is
called multiple inheritance.
Hierarchical Inheritance
• When a single base class is used for the derivation of two or more classes, it is
known as hierarchical inheritance.
13

Multilevel Inheritance
• When a class is derived from another derived class, that is, the derived class acts
as a base class, such a type of inheritance is known as multilevel inheritance.
Hybrid Inheritance
• A combination of one or more types of inheritance is known as hybrid
inheritance.
Multipath Inheritance
• When a class is derived from two or more classes, those are derived from the
same base class. Such a type of inheritance is known as multipath inheritance.
14

16
#include<conio.h>
class emp
{
public:
int eno;
char name[20],des[20];
void get()
{
cout<<"Enter the employee number:";
cin>>eno;
cout<<"Enter the employee name:";
cin>>name;
cout<<"Enter the designation:";
cin>>des;
}
};

17
class salary:public emp {
float bp,hra,da,pf,np;
public:
void get1() {
cout<<"Enter the basic pay:";
cin>>bp;
cout<<"Enter the Human Resource Allowance:";
cin>>hra;
cout<<"Enter the Dearness Allowance :";
cin>>da;
cout<<"Enter the Profitablity Fund:";
cin>>pf; }
void calculate()
{
np=bp+hra+da-pf;
}
void display()
{
cout<<eno<<"t"<<name<<"t"<<des<<"t"<<bp<<"t"<<hra<<"t"<<da<<"t"<<pf<<"t"<<
np<<"n";
}
};

18
void main()
{
int i,n;
char ch;
salary s[10];
clrscr();
cout<<"Enter the number of employee:";
cin>>n;
for(i=0;i<n;i++)
{
s[i].get();
s[i].get1();
s[i].calculate();
}
cout<<"ne_no t e_namet des t bp t hra t da t pf t np n";
for(i=0;i<n;i++)
{
s[i].display();
}
getch();
}

19
Write a program to show single inheritance between two classes.
class ABC {
protected:
char name[15];
int age;
};
class abc : public ABC // public derivation
{
float height;
float weight;
public:
void getdata() {
cout<<“n Enter Name and Age:”;
cin>>name>>age;
cout<<“n Enter Height and Weight:”;
cin>>height >>weight; }
void show()
{
cout<<“n Name:”<<name <<“n Age:”<<age<<“ Years”;
cout<<“n Height:”<<height <<“ Feets”<<“n Weight:”<<weight <<“Kg.”;
} };

20
int main()
{
clrscr();
abc x;
x.getdata(); // Reads data through keyboard.
x.show(); // Displays data on the screen.
return 0;
}
OUTPUT
Enter Name and Age : Santosh 24
Enter Height and Weight : 4.5 50
Name : Santosh
Age : 24 Years
Height : 4.5 Feets
Weight : 50 Kg.

21
Multilevel Inheritance
#include<conio.h>
class top { //base class
public :int a;
void getdata() {
cout<<"nnEnter first Number :::t";
cin>>a; }
void putdata() {
cout<<"nFirst Number Is :::t"<<a; } };
//First level inheritance
class middle :public top // class middle is derived_1
{
Public: int b;
void square()
{
getdata();
b=a*a;
cout<<"nnSquare Is :::"<<b;
}
};

22
//Second level inheritance
class bottom :public middle // class bottom is derived_2
{
public:
int c;
void cube()
{
square();
c=b*a;
cout<<"nnCube :::t"<<c;
}
};
int main()
{
clrscr();
bottom b1;
b1.cube();
getch();
}

23
Write a program to create multilevel inheritance. Create classes A1, A2, and A3.
// Multilevel inheritance //
class A1 // Base class {
protected:
char name[15];
int age; };
class A2 : public A1 { // Derivation first level
protected:
float height;
float weight; };
class A3 : public A2 { // Derivation second level
protected:
char sex;
public:
void get() // Reads data {
cout<<“Name:”; cin>>name;
cout<<“Age:”; cin>>age;
cout<<“Sex:”; cin>>sex;
cout<<“Height:”; cin>>height;
cout<<“Weight:”; cin>>weight; }

24
void show() // Displays data
{
cout<<“nName:” <<name;
cout<<“nAge:” <<age <<“ Years”;
cout<<“nSex:” <<sex;
cout<<“nHeight:” <<height <<“ Feets”;
cout<<“nWeight:” <<weight <<“ Kg.”;
}
}; int main()
{
clrscr();
A3 x; // Object Declaration
x.get(); // Reads data
x.show(); // Displays data
return 0;
}
OUTPUT
Name : Balaji Age : 26 Sex : M Height : 4 Weight : 49.5
Name : Balaji Age : 26 Years Sex : M Height : 4 Feets Weight : 49.5 Kg.

25
#include<iostream.h> Multiple Inhertiance
#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;
} };

26
class statement:public student,public sports
{
int tot,avg;
public:
void display() {
tot=(m1+m2+sm);
avg=tot/3;
cout<<"nntRoll No : "<<rno<<"ntTotal : "<<tot;
cout<<"ntAverage : "<<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

27
class statement:public student,public sports
{
int tot,avg;
public:
void display() {
tot=(m1+m2+sm);
avg=tot/3;
cout<<"nntRoll No : "<<rno<<"ntTotal : "<<tot;
cout<<"ntAverage : "<<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

28
Write a program to derive a class from multiple base classes.
// Multiple Inheritance //
class A {protected: int a;}; // class A declaration
class B {protected: int b;}; // class B declaration
class C {protected: int c;}; // class C declaration
class D {protected: int d;}; // class D declaration
// class E : public A, public B, public C, public D
class E : public A,B,C,D // Multiple derivation
{
int e;
public:
void getdata()
{
cout<<“n Enter values of a,b,c & d & e:”;
cin>>a>>b>>c>>d>>e;
}
void showdata()
{
cout<<“n a=”<<a <<“ b=”<<b <<“ c = ”<<c <<“ d= ”<<d <<“ e=”<<e;
}
};

29
int main()
{
clrscr();
E x;
x.getdata(); // Reads data
x.showdata(); // Displays data
return 0;
}
OUTPUT
Enter values of a,b,c & d & e : 1 2 4 8 16
a=1 b = 2 c = 4 d= 8 z= 16

30
Hierarchical Inheritance
#include<conio.h>
class person
{
private:
char name[20];
long int phno;
public:
void read()
{
cout<<"n Enter name ";
cin>>name;
cout<<"n Enter Phno.=";
cin>>phno;
}
void show()
{
cout<<"n Name="<<name;
cout<<"n Phone="<<phno;
}
};

31
class teacher:public person
{
private:
char dept_name[10];
char qual[10];
public:
void read()
{
person::read();
cout<<"n Enter dept_name andQualification=";
cin>>dept_name>>qual;
}
void show()
{
person::show();
cout<<"n Departement="<<dept_name;
cout<<"n Qualififcation="<<qual;
}
};

32
main()
{
clrscr();
student s1;
cout<<"n************************ Enter student Information******************";
s1.read();
cout<<"n************************ Displaying Student Information*************";
s1.show();
teacher t1;
cout<<"n************************** Enter Teacher Information*****************";
t1.read();
cout<<"n*****************************Displaying Teacher
Information************";
t1.show();
getch();
}

33
Write a program to show hierarchical inheritance.
class red {
public:
red() {cout<<“Red”;}; };
class yellow {
public:
yellow() {cout<<“Yellow”;} };
class blue {
public:
blue() {cout<<“Blue”;} };
class orange : public red, public yellow {
public:
orange() {cout<<“=Orange”;} };
class green : public blue, public yellow {
public:
green() {cout<<“=Green”;} };
class violet : public red, public blue {
public:
violet() {cout<<“=Violet”;} };

34
class reddishbrown : public orange, public violet {
public:
reddishbrown() {cout<<“=Reddishbrown”;} };
class yellowishbrown : public green, public orange {
public:
yellowishbrown() {cout<<“=Yellowishbrown”;} };
class bluishbrown : public violet, public green {
public:
bluishbrown() {cout<<“=Bluishbrown”;} };
int main() {
clrscr();
reddishbrown r;
endl(cout);
bluishbrown b;
endl(cout);
yellowishbrown y;
endl(cout);
return 0; }
OUTPUT
Red Yellow = Orange Red Blue = Violet = Reddishbrown
Red Blue = Violet Blue Yellow = Green = Bluishbrown
Blue Yellow = Green Red Yellow = Orange = Yellowishbrown

class minus {
Protected: int n1,n2,diff;
Public: void sub() {
cout<<"nFor Subtraction:";
cout<<"nEnter the first number: ";
cin>>n1;
cout<<"nEnter the second number: ";
cin>>n2;
diff=n1-n2; } };
class result: public plus, public minus {
Public: void display() {
cout<<"nSum of "<<num1<<" and "<<num2<<"= "<<sum;
cout<<"nDifference of "<<n1<<" and "<<n2<<"= "<<diff; } };
void main() {
clrscr();
result z;
z.getdata(); z.add();
z.sub(); z.display();
getch(); }
35

#include<conio.h>
class arithmetic {
Protected: int num1, num2;
Public: void getdata() {
cout<<"For Addition:";
cout<<"nEnter the first number: ";
cin>>num1;
cout<<"nEnter the second number: ";
cin>>num2; } };
class plus: public arithmetic {
Protected: int sum;
Public: void add() {
sum=num1+num2;} };
36

• CONSTRUCTORS, DESTRUCTORS, AND INHERITANCE
• The constructors are used to initialize member variables of the
object, and the destructor is used to destroy the object. The
compiler automatically invokes constructors and destructors. The
derived class does not require a constructor, if the base class
contains a zero-argument constructor. In case the base class has
a parameterized constructor, then it is essential for the derived
class to have a constructor. The derived class constructor passes
arguments to the base class constructor. In inheritance, normally
derived classes are used to declare objects. Hence, it is necessary
to define constructors in the derived class. When an object of a
derived class is declared, the constructors of the base and
derived classes are executed.
37

Write a program to use constructor and destructor in all classes (base and derived class). Read
and display the data.
#include<conio.h>
class A1 {
Protected: char name[15];
int age;
A1() {
cout<<“Name:”; cin>>name;
cout<<“Age:”; cin>>age; }
~A1() {
cout<<“nName:” <<name;
cout<<“nAge:” <<age; } };
class A2 : public A1 {
Protected: float height;
float weight;
A2(){
cout<<“Height:”; cin>>height;
cout<<“Weight:”; cin>>weight; }
38

~ A2() {
cout<<“nHeight:”<<height;
cout<<“nWeight:”<<weight; }
};
class A3 : public A2 {
char sex;
public:
A3() {
cout<<“Sex:”; cin>>sex; }
~ A3() {
cout<<“nSex:” <<sex; } };
int main()
{
clrscr();
A3 x;
return 0;
}
OUTPUT
Name : Ajay Age : 20 Height : 4.5 Weight : 40 Sex : M
Sex : M Height : 4.5 Weight : 40 Name : Ajay Age : 20
39

• In the above program, classes A1, A2, and A3 have their own constructors and
destructors. Here, the class A1 is the base class of A2, and A2 is the base class
of A3 or, in other words, A3 is a derived class of A2 and A2 is a derived class of A1.
Execution of constructors: The execution of constructors takes place from the base
class to the derived class. Thus, the sequence of the execution of constructors
is A1(), A2(), and A3().
Execution of destructors: The execution of destructors is in opposite order as
compared with constructors, that is, from the derived class to the base class. Thus,
the sequence of the execution of destructors is A3(), A2(), and A1(). The object
created last destroyed first. The same rule is applicable in the execution of
constructors and destructors in inheritance.
40

Inheritance in C++

More Related Content

What's hot (20)

Similar to Inheritance in C++ (20)

Recently uploaded (20)

Inheritance in C++