Inheritance

Introduction

– The mechanism of deriving a new class from an old one is called inheritance.
– Base and derived class
– Types of inheritance:
– Simple
– Multiple
– Multilevel
– Hierarchical
– Hybrid
Derived Class

Class derived-class-name: visibility-name base-class-name

– The default visibility mode is private.
– Visibility mode specifies whether the features of the base class are privately derived or publicly derived.
class ABC: private XYZ
{
members of ABC
};

class ABC: public XYZ

{
members of XYZ
};
 CODE

#include<iostream> class B:A

using namespace std; {
public:
OUTPUT: class A
{ void disp(){cout<<x;}
Error int x; };
‘x’ is privately public:
defined int y; int main()
A() {
{
B ob;
x=10;y=20;
} ob.disp();
}; }
 CODE

#include<iostream> class B:A

using namespace std; {
public:
OUTPUT: class A
{ void disp(){cout<<y;}
20 int x; };
public:
int y; int main()
A() {
{
B ob;
x=10;y=20;
} ob.disp();
}; }
Derived Class

class ABC: XYZ

{
members of ABC
};
– When a base class is privately inherited by a derived class, public members of
the base class become private members of the derived class and therefore the
public members of the base class can only be accessed by the member
functions of the derived class.
– They are inaccessible to the objects of the derived class.
 CODE

#include<iostream> class B:public A

using namespace std;
{
class A };
OUTPUT:
{
20 int x; int main()
public:
{
int y;
A()
B ob;
{ cout<<ob.y;
x=10;y=20; }
}
};
 CODE

#include<iostream> class B:public A

using namespace std; {
public:
OUTPUT: class A void disp()
{
{
cout<<x;
Error int x;
}
‘x’ is declared as public:
};
private int y;
A() int main()
{ {
x=10;y=20; B ob;
} ob.disp();
}; }
Derived Class

class ABC: public XYZ

{
members of ABC
};
– When a base class is publicly inherited by a derived class, public members of the
base class become public members of the derived class and therefore the public
members of the base class can only be accessed by the member functions of the
derived class.
– They are accessible to the objects of the derived class.
– However, the private data members are not accessible.
Derived Class

– Functionalities can be added to the derived class as data members of member

functions.
– This leads to increased functionalities of the base class.
 Simple Inheritance

#include<iostream> class B:public A

{
using namespace std; public:
void disp()
class A {
OUTPUT: {
int prod=y*x;
cout<<prod;
int x; }
Error };
public:
int y; int main()
set(){ {
x=10;y=20; B ob;
ob.set();
} ob.disp();
}; }
 Simple Inheritance

#include<iostream> class B:public A

using namespace std; {
public:
class A
void disp()
{
{
int x;
OUTPUT: public: int prod=y*ret_x();
int y; cout<<prod;
set(){ }
200 x=10;y=20; };
}
ret_x(){ int main()
return x;
{
}
B ob;
ret_y(){
return y;
ob.set();
} ob.disp();
}; }
 Simple Inheritance

#include<iostream> class B:private A

using namespace std; {
public:
class A
void disp()
{
{
OUTPUT: int x;
int prod=ret_y()*ret_x();
public:
int y; cout<<prod;
Error set(){ }
ob.set() x=10;y=20; };
}
ret_x(){ int main()
return x;
{
}
B ob;
ret_y(){
return y;
ob.set();
} ob.disp();
}; }
 Simple Inheritance

#include<iostream> class B:private A

using namespace std; {
public:
class A
void disp()
{
{
int x;
OUTPUT: public: set();
int y; int prod=ret_y()*ret_x();
set(){ cout<<prod;
200 x=10;y=20; }
} };
ret_x(){
return x;
int main()
}
{
ret_y(){
return y;
B ob;
} ob.disp();
}; }
 Simple Inheritance

#include<iostream> class B:public A

{
using namespace std;
public:
void disp(){
OUTPUT: class A cout<<"class B";
{ }
Class B public: };

disp(){ int main()

cout<<"Class A"; {
} B ob;
}; ob.disp();
}
Simple Inheritance

– When the function with same name is defined in both base and derived class,
then the derived class definition overrides the base class definition.

– How to access the disp() method of class A?

 Code

#include<iostream> class B:public A

{
using namespace std; public:
void disp(){
OUTPUT: A::disp();
class A
cout<<"class B";
Class A { }
Class B public: };
disp(){
int main()
cout<<"Class A"; {
} B ob;
}; ob.disp();
}
Protected Access Specifier

– A member declared as protected is accessible by the member functions within

its class and any class immediately derived from it.
– It cannot be accessed by functions outside these two classes.
– When a protected member is inherited in public mode, it becomes protected in the
derived class and therefore is accessible by the member functions of the derived
class. It is ready for further inheritance.
– A protected member if inherited in private mode, becomes private in the derived
class. it is not available for further inheritance.
Modes
 Multilevel Inheritance

#include<iostream> class test1:public test

using namespace std;
{
class test{ };
OUTPUT: int x;
protected: class test2:public test1
int z;
10 {
public:
20 int y; };
30 test(){
x=10;y=20;z=30; int main()
}
{
disp(){
cout<<x<<"\n"<<y<<"\n"<<z; test2 ob;
} ob.disp();
}; }
 Multilevel Inheritance

#include<iostream> class test1:public test

using namespace std;
{
class test{ };
OUTPUT: int x;
protected: class test2:protected test1
int z;
Error {
public:
‘disp()’ function int y; };s
is not accessible test(){
x=10;y=20;z=30; int main()
}
{
disp(){
cout<<x<<"\n"<<y<<"\n"<<z; test2 ob;
} ob.disp();
}; }
 Multilevel Inheritance

#include<iostream> class test1:protected test

using namespace std; {
};
class test{
OUTPUT: int x; class test2:public test1
protected:
{
int z;
10 public:
public:
20 int y;
disp1(){disp();}
30 test(){ };
x=10;y=20;z=30;
} int main()
disp(){ {
cout<<x<<"\n"<<y<<"\n"<<z; test2 ob;
} ob.disp1();
}; }
 Multiple Inheritance

class A{ class C{
int x; public: int z;
public: void disp2(){
void disp(){ z=30;
OUTPUT: x=10; cout<<"\nIn Class C"<<z;
cout<<"\nIn Class A"<<x; }};
}};
In Class A10
class D:private A, protected B, public C
In Class B20 class B{ {
In Class C30 protected: public:
int y; display(){disp();disp1();disp2();}
public: };
void disp1(){
y=20; int main(){
cout<<"\nIn Class B"<<y; D ob; ob.display();
}}; }
 Multiple Inheritance

#include<iostream> class C
using namespace std; {
public:
class A void disp(){
OUTPUT: { cout<<"\nIn Class C";
public:
}
void disp(){
Error cout<<"\nIn Class A";
};
Multiple }
class D:public A, B, C
candidates };
{
‘disp()’ class B };
{
public: int main()
void disp(){ {
cout<<"\nIn Class B"; D ob;
} ob.disp();
}; }
 Multiple Inheritance

#include<iostream>
using namespace std; class C
{
class A public:
{ void disp(){
public: cout<<"\nIn Class C";
OUTPUT: void disp(){ }
cout<<"\nIn Class A"; };
}
In Class A }; class D:public A, B, C
{
class B };
{
public: int main()
void disp(){ {
cout<<"\nIn Class B"; D ob;
} ob.A::disp();
}; }
 Multiple Inheritance

#include<iostream> class C
using namespace std; {
public:
class A void disp(){
OUTPUT: { cout<<"\nIn Class C";
public: }
void disp(){ };
Error cout<<"\nIn Class A";
B and C are } class D:public A, B, C
inherited }; {
};
privately class B
{ int main()
public: {
void disp(){ D ob;
cout<<"\nIn Class B"; ob.A::disp(); ob.B::disp();
} ob.C::disp();
}; }
 Multiple Inheritance

#include<iostream> class C
using namespace std; {
public:
class A void disp(){
{
OUTPUT: public:
cout<<"\nIn Class C";
}
void disp(){
};
In Class A cout<<"\nIn Class A";
}
In Class B };
class D:public A, public B, public C{
};
In Class C
class B
{ int main()
public: {
void disp(){ D ob;
cout<<"\nIn Class B"; ob.A::disp(); ob.B::disp();
} ob.C::disp();
}; }
 Hierarchical Inheritance

OUTPUT:
class shape{ class square: protected shape{
protected: public:
Enter dimensions of int l,b,h; get(){
rectangle10 20 public: cout<<"\nEnter dimensions of square";
disp(){ cin>>l; b=l; h=0;
cout<<l<<b<<h; }
10 area(){
}};
20 0 200 disp();
cout<<l*b;
class rect: protected shape{
}};
Enter public:
dimensions of square10 get(){ int main(){
cout<<"Enter dimensions of rectangle"; rect ob;
cin>>l; cin>>b; h=0; square ob1;
10 10 0 } ob.get();
100 area(){ ob.area();
disp(); ob1.get();
cout<<l*b; ob1.area();
}}; }
Hybrid Inheritance
 Code
OUTPUT:

Error

Ambiguity in disp()
#include<iostream> class C: public A
using namespace std; {
};
class A
{
public: class D:public B, public C
disp() {
{ };
cout<<"Class A";
}
int main()
};
{
class B: public A D ob;
{ ob.disp();
}; }
Virtual Base Class

– When a class is made a virtual base class, C++ takes necessary care to see that
only one copy of that class is inherited, regardless of how many inheritance
paths exist between the virtual base class and a derived class.
 Code

#include<iostream> class C: public virtual A

using namespace std; {
OUTPUT: };
class A
{
Class A class D: public B, public C
public:
disp() {
{ };
cout<<"Class A";
}
int main()
};
{
class B: virtual public A D ob;
{ ob.disp();
}; }
Question

– Can class inheritance be avoided?

 Code

#include<iostream> class C: public virtual A

using namespace std; {
OUTPUT: };
class A final
{
Error class D:public B, public C
public:
disp() {
{ };
cout<<"Class A";
}
int main()
};
{
class B: virtual public A D ob;
{ ob.disp();
}; }
 Code

#include<iostream> class B: public A

{
using namespace std;
OUTPUT: public:
void disp()
Class B class A {
{ cout<<"Class B";
}
public: };
disp()
{ int main()
cout<<"Class A"; {
B ob;
} ob.disp();
}; }
Question

– Can method overriding be avoided?

 Code

#include<iostream> class B: public A

OUTPUT: using namespace std; {
public:
Error class A void disp()
Overriding final {
{
function public:
cout<<"Class B";
Virtual void disp() final
}
{
cout<<"Class A"; };
}
}; int main()
{
(); B ob;
} ob.disp
 Constructor Invocation

#include<iostream> class C: public B

OUTPUT: using namespace std;
{
In Class A class A public:
In Class B { C(){cout<<"In class C";}
In Class C public: };
A(){cout<<"In class A";}
};

class B: public A int main()

{ {
public:
B(){cout<<"In class B";}
C ob;
}; }
 Constructor Invocation

class A{ class D{
public: public:
OUTPUT: A(){cout<<"In class A\n";} D(){cout<<"In class D\n";}
}; };
In Class A
In Class B class B: public A{ class E: public C, public D{
In Class C public: public:
In Class D B(){cout<<"In class B\n";} E(){cout<<"In class E";}
In Class E }; };

class C: public B{
public: int main(){
C(){cout<<"In class C\n";} E ob;
}; }
 Constructor Invocation

class A{ class D{
public: public:
OUTPUT: A(){cout<<"In class A\n";} D(){cout<<"In class D\n";}
}; };
In Class D
In Class A class B: public A{ class E: public D, public C{
In Class B public: public:
In Class C B(){cout<<"In class B\n";} E(){cout<<"In class E";}
In Class E }; };

class C: public B{
public: int main(){
C(){cout<<"In class C\n";} E ob;
}; }
 Constructor Invocation

class A{ class D{
public: public:
OUTPUT: A(){cout<<"In class A\n";} D(){cout<<"In class D\n";}
}; };
In Class A
In Class B class B: public A{ class E: public D, virtual public C{
In Class C public: public:
In Class D B(){cout<<"In class B\n";} E(){cout<<"In class E";}
In Class E }; };

class C: public B{
public: int main(){
C(){cout<<"In class C\n";} E ob;
}; }
 Constructor Invocation

#include<iostream> class C: public A, public B

using namespace std;
{
class A public:
OUTPUT: { C(int x, int y, int z){cout<<z;}
public:
Error A(int x){cout<<x;}
};
};
int main()
class B
{ {
public: C ob(2,3,4);
B(int y){cout<<y;} }
};
 Constructor Invocation

#include<iostream> class C: public A, public B

using namespace std;
{
class A public:
OUTPUT: { C(int x, int y, int z):A(x),B(y){cout<<z;}
public:
234 A(int x){cout<<x;}
};
};
int main()
class B
{ {
public: C ob(2,3,4);
B(int y){cout<<y;} }
};
Constructor Invocation

Constructor (arglist) : initialization-section

{
Assignment-section;
}

– Initialization section is used to provide values to base class constructors.

– Assignment section is used to provide values to the derived class data
members.
 Constructor Invocation

#include<iostream> class C: public A, public B

using namespace std;
{
class A public:
OUTPUT: { C(int x, int y, int z):B(x),A(y){cout<<z;}
public:
324 A(int x){cout<<x;}
};
};
int main()
class B
{ {
public: C ob(2,3,4);
B(int y){cout<<y;} }
};
 Constructor Invocation

#include<iostream> class C: public B

using namespace std;
{
class A public:
OUTPUT: { C(int x, int y, int z):B(x,y){cout<<z;}
public:
324 A(int x){cout<<x;}
};
};
int main()
class B: public A
{ {
public: C ob(2,3,4);
B(int x, int y):A(x){cout<<y;} }
};
 Constructor Invocation

#include<iostream> class C: public B

using namespace std;
{
class A public:
OUTPUT: { C(int x, int y, int z):B(2*x,3*y){cout<<z;}
public:
465 };
A(int x){cout<<x;}
};
int main()
class B: public A {
{
public:
C ob(2,3,5);
B(int x, int y):A(x){cout<<y;} }
};
 Member Classes

#include<iostream> class C
using namespace std; {
A x;
class A
{ B y;
public: int z;
OUTPUT: int x; public:
get1(int x1){x=x1;} get3(int m,int n, int o){x.get1(m);y.get2(n);z=o;}
234 disp1(){cout<<x;}
void disp3(){x.disp1();y.disp2();cout<<z;}
};
};
class B
{ int main()
public: {
int y; C ob;
B(){}
ob.get3(2,3,4);
get2(int y1){y=y1;}
disp2(){cout<<y;} ob.disp3();
}; }
 Pointer to Object

#include<iostream> int main()

using namespace std;
{
class test{ test ob1;
OUTPUT: int x; test *ptr=&ob1;
public: ptr->get();
10 void get(){
ptr->put();
x=10;
}
}
void put(){
cout<<x;
}
};
 Pointer to Object

#include<iostream> int main()

using namespace std;
{
class test{ test *ptr=new test;
OUTPUT: int x; ptr->get();
public: ptr->put();
10 void get(){
}
x=10;
}
void put(){
cout<<x;
}
};
 Pointer to Object

#include<iostream>
using namespace std;
int main()
{
class test
{
test *ptr=new test[5];
OUTPUT:
int x; for(int i=0;i<5;i++)
public:
void get(int i) {
0 10 20 30 40 { ptr->get(i);
x=10*i;
} ptr->put();
void put() ptr++;
{
cout<<x; }
} }
};
 Pointer to Derived Classes

class test{ int main()

protected: {
test ob;
int x;
test1 ob1;
public:
OUTPUT: void get(){ x=10;} test *ptr;
void put() { cout<<x;}}; ptr=&ob;
10 10
ptr->get();
class test1:public test{ ptr->put();
int y;
ptr=&ob1;
public: ptr->get();
void get1(){ y=20;} ptr->put();
void put1(){ cout<<y;}}; }
 Pointer to Derived Classes
with same function
class test{ int main()
protected: {
test ob;
int x;
test1 ob1;
public:
OUTPUT: void get(){ x=10;} test *ptr;
void put() { cout<<x;}}; ptr=&ob;
10 10
ptr->get();
class test1:public test{ ptr->put();
int y;
ptr=&ob1;
public: ptr->get();
void get(){ y=20;} ptr->put();
void put(){ cout<<y;}}; }
Virtual Functions

– Polymorphism refers to the property by which objects belonging to different

classes are able to respond to the same message, but in different forms.
– An essential requirement of polymorphism is the ability to refer to objects
without any regard to their classes.
– This necessitates the use of a single pointer variable to refer to the objects of
different classes.
– Base class pointer can execute only the base class members even if provided
with the address of derived class object.
Virtual Functions

– When the same function name is used in both the classes, then the function in
the base class is made virtual so that the function call is postponed till runtime.
– So, the linking between the object and the pointer is done at runtime based on
the object it refers to rather than the type of pointer it is.
 Code

class test{ int main()

protected: {
test ob;
int x;
test1 ob1;
public:
OUTPUT: virtual void get(){ x=10;} test *ptr;
virtual void put() { cout<<x;}}; ptr=&ob;
10 20
ptr->get();
class test1:public test{ ptr->put();
int y;
ptr=&ob1;
public: ptr->get();
void get(){ y=20;} ptr->put();
void put(){ cout<<y;}}; }
 Code

class test{ int main()

protected: {
int x; test ob;
public: test1 ob1;
OUTPUT: void get(){ x=10;}
void put(){ cout<<"\n"<<x;} test *ptr;
Error }; ptr=&ob;
‘put1’ not defined ptr->get();
in class test class test1:public test{ ptr->put();
int y;
public: ptr=&ob1;
void get(){ y=20;} ptr->get();
void put(){ cout<<"\n"<<y;} ptr->put();
void put1(){ cout<<"Hello";} ptr->put1();
}; }
Pure Virtual Function

– We can declare a function virtual inside the base class and redefine it in the
derived classes.
– This function in the base class is a placeholder.
– Referred to as ‘do-nothing’ function
– virtual void display() = 0;
 Code

#include<iostream> int main()

using namespace std;
{
class test{ test1 ob;
public:
OUTPUT: virtual void put()=0; ob.put();
}; }
Hello
class test1:public test
{
public:
void put(){
cout<<"Hello";
}
};
 Code

#include<iostream> int main()

using namespace std;
{
class test{ test ob;
public:
OUTPUT: virtual void put()=0; ob.disp();
void disp(){cout<<"Class A";}
Error };
test1 ob;
Class ‘test’ is class test1:public test{ ob.put();
abstract class public:
}
void put(){
cout<<"Hello";
}
};
 Code

class test{ int main()

public: {
virtual void put()=0;
test *ptr;
void disp(){cout<<"Class A";}
};
test1 ob;
OUTPUT:
ptr=&ob;
Class A class test1:public test{ ptr->disp();
Hello public: ptr->put();
void put(){ }
cout<<"Hello";
}
};
Abstract Class

– A class containing a pure virtual function is called as abstract class.

– It is used to provide some traits to the derived classes and to create a base
pointer required for achieving run time polymorphism.
– It cannot be used to create objects.
– We can have pointers and references of abstract class type.
– If we do not override the pure virtual function in derived class, then derived class also
becomes abstract class.
– An abstract class can have constructors.