Inheritance
Inheritance
• Inheritance is the ability of one class to inherit the properties of
another class. A new class can be created from an existing class. The
existing class is called BASE CLASS or SUPER CLASS and the new class
is called DERIVED CLASS or SUB CLASS.
• Example:
Car inherits from another class auto_mobile
Computer_student inherits from another class student
Arrange concepts into an inheritance
hierarchy
• Concepts at higher levels are more general
• Concepts at lower levels are more specific (inherit
properties of concepts at higher levels)
Vehicle
Wheeled vehicle Boat
Car Bicycle
2-door 4-door
Advantages of inheritance
• When a class inherits from another class, there are three benefits:
(1) You can reuse the methods and data of the existing class
(2) You can extend the existing class by adding new data and new
methods
(3) You can modify the existing class by overloading its methods
with your own implementations
Inheritance is the property that allows the
reuse of an existing class to build a new class
Base Class Derived class
Methods Base class methods
and +
Properties Additional methods
General Syntax for Inheritance
class <derived classname > : access-specifier <base classname >
{
---
----
};
Access specifier
• Public - The members declared as Public are accessible
from outside the Class through an object of the class.
• Protected - The members declared as Protected are
accessible from outside the class BUT only in a class
derived from it.
• Private - These members are only accessible from
within the class. No outside Access is allowed.
Accessibility of base class member
Access Specifier Accessible from Accessible from Accessible from
own class derived object outside class
class(inheritable)
Public Yes Yes Yes
Protected Yes Yes No
Private Yes No No
Inheritance
Single Inheritance Hierarchical
Inheritance
Multilevel Multiple Inheritance
Inheritance
Single Inheritance
A class can be derived from a single base class is called single
inheritance
Person
Employee
Multilevel
Inheritance
A class be can derived from a derived class which is known as multilevel
inheritance.
Vehicle Person
Car Employee
Racing car Part time
Employee
Multiple Inheritance
It is the process of creating new class from more than one base
classes.
Syntax :
class <derived class >:<access specifier>
base_class1,<access specifier> base_class2...
{
private :
// members;
protected :
Person Employee
// members;
public :
//memebers;
};
Teacher
Hierarchical Inheritance
If more than one class is inherited from a base class, it's known as hierarchical
inheritance. In general, all features that are common in child classes are included
in base class in hierarchical inheritance.
Employee
Permanent Temporary
Employee Employee
Hybrid Inheritance
Hybrid is nothing but the combination of Multilevel
and multiple Inheritance
Multipath problem void sum()
class B: virtual public A {
#include<iostream>
{ d=a+b+c;
using namespace std; protected:
}
class A int b;
public: void display()
{
void setb() {
protected: {
b=20; cout<<"Sum of a,b,c is: " << d ;
int a;
} }
public: };
};
void seta() class C: virtual public A
{ int main()
{
protected: {
a=10; int c;
public: D d1;
}
void setc() d1.seta();
}; {
d1.setb();
c=30;
} d1.setc();
}; d1.sum();
class D:public B,public C
{ d1.display();
private: return 0;
int d;
}
Same Data Member Name in Base
and Derived Class
#include<iostream> class B:public A
using namespace std; { main()
{
class A int x; B b;
{ public: A a;
protected: B(){x=10;} a.print();
int x; b.print();
public: }
void print()
A(){x=5;}
{
void print()
cout<<"inside B"<<endl;
{
cout<<x<<endl;
cout<<"inside
A"<<endl;} }
Order of Constructor Call
Base class constructors are always called in the derived class constructors.
Whenever you create derived class object, first the base class default
constructor is executed and then the derived class's constructor finishes
execution.
Points to Remember
1.Whether derived class's default constructor is called or parameterised is
called, base class's default constructor is always called inside them.
2.To call base class's parameterised constructor inside derived class's
parameterised constructor, we must mention it explicitly while declaring
derived class's parameterized constructor.
Default constructor
class Derived : public Base
#include <iostream>
{
using namespace std; int y;
class Base
{ public:
Derived()
int x;
{
cout << "Derived default constructor\n";
public: }
Base() };
{
int main()
cout << "Base default {
constructor\n";
Base b;
} Derived d1;
parameterized constructor(Base derived not called)
class Derived : public Base
#include <iostream>
{
using namespace std; int y;
class Base public:
{ Derived()
int x; {
public: cout << "Derived default constructor\n";
Base() }
{ Derived(int i)
{
cout << "Base default constructor\n";
cout << "Derived parameterized constructor\n";
}
}
Base(int i) };
{ int main()
x = i; {
cout << "Base Parameterized Constructor\ Base b;
n"; Derived d1;
} Derived d2(10);
parameterized constructor(Base derived called)
class Derived : public Base
#include <iostream> {
using namespace std; int y;
class Base
public:
{
Derived()
int x; {
cout << "Derived default constructor\n";
public: }
Base()
Derived(int i):Base(i)
{
{
cout << "Base default constructor\n"; cout << "Derived parameterized constructor\n";
} }
Base(int i) };
{
int main()
x = i; {
cout << "Base Parameterized Constructor\n"; Base b;
} Derived d1;
Derived d2(10);
};
Base class Parameterized Constructor in Derived class Constructor
We can explicitly mention to call the Base class's parameterized constructor
when Derived class's parameterized constructor is called.
Constructor call in Multiple Inheritance
Its almost the same, all the Base class's constructors are called inside derived class's
constructor, in the same order in which they are inherited.
class A : public B, public C ;
In this case, first class B constructor will be called, then class C constructor and then
class A constructor.
3 Types of Access Specifiers
• Type 1: inherit as private
Base Derived
private members inaccessible
protected members private members
public members private members
3 Types of Access Specifiers
• Type 2: inherit as protected
Base Derived
private members inaccessible
protected members protected members
public members protected members
3 Types of Access Specifiers
• Type 3: inherit as public
Base Derived
private members inaccessible
protected members protected members
public members public members
Public Inheritance:
All Public members of the Base Class become Public Members of the derived class &
All Protected members of the Base Class become Protected Members of the Derived
Class.
class Base {
public: int a;
protected: int b;
private: int c;
};
class Derived:public Base {
void doSomething() {
a = 10; //Allowed
b = 20; //Allowed
c = 30; //Not Allowed, Compiler Error
}
};
int main() {
Derived obj;
obj.a = 10; //Allowed
obj.b = 20; //Not Allowed, Compiler Error
obj.c = 30; //Not Allowed, Compiler Error
}
Private Inheritance:
All Public members of the Base Class become Private Members of the Derived class &
All Protected members of the Base Class become Private Members of the Derived Class.
Class Base {
public: int a;
protected: int b;
private: int c; };
class Derived:private Base //defaults access specifier is private {
void doSomething() {
a = 10; //Allowed
b = 20; //Allowed
c = 30; //Not Allowed, Compiler Error }
};
class Derived2:public Derived {
void doSomethingMore() {
a = 10; //Not Allowed, Compiler Error, a is private member of Derived now
b = 20; //Not Allowed, Compiler Error, b is private member of Derived now
c = 30; //Not Allowed, Compiler Error }
};
int main() {
Derived obj; obj.a = 10; //Not Allowed, Compiler Error
obj.b = 20; //Not Allowed, Compiler Error
obj.c = 30; //Not Allowed, Compiler Error }
• Protected Inheritance:
All Public members of the Base Class become Protected Members of the derived class
& All Protected members of the Base Class become Protected Members of the Derived
Class.
Class Base {
public: int a;
protected: int b;
private: int c; };
class Derived:protected Base {
void doSomething() {
a = 10; //Allowed
b = 20; //Allowed
c = 30; //Not Allowed, Compiler Error }
};
class Derived2:public Derived {
void doSomethingMore() {
a = 10; //Allowed, a is protected member inside Derived & Derived2 is
public derivation from Derived, a is now protected member of Derived2
b = 20; //Allowed, b is protected member inside Derived & Derived2 is public
derivation from Derived, b is now protected member of Derived2
c = 30; //Not Allow ed, Compiler Error }
};
int main() {
Derived obj; obj.a = 10; //Not Allowed, Compiler Error
obj.b = 20; //Not Allowed, Compiler Error
obj.c = 30; //Not Allowed, Compiler Error
}
