Inheritance

Chapter 3
Inheritance
• Inheritance is the process of
creating new classes, called
derived classes, from existing or
base classes.
• Its big payoff is that it permits
code reusability.
– saves time
– can be distributed as libraries.
 Example : Banking
Scenario: Consider Bank Accounts which are of
various types such as Savings, Current, Loan, PPF.
• It is obvious that these types of accounts are similar.
Also they have some specific attributes/ behaviors.
• Through inheritance a base class can be created
and all common attributes/ behaviors can be moved
to the base class.
 Base Class/ Derived class/
Parent Class/
Super class
Example : Banking Child Class/
Sub class
class BankAccount{ class SavingAccount: public BankAccount
public: Object of SavingAccount {
s1 public:
int accno; Syntax for
int NumberOfTransactions;
accno
float accBalance; inheriting class
static int minimumBalance,
string name; accBalance Inherited
transactionsLimit;
members
long mobile[2];name
mobile[] };// end of class SavingAccount
};// end of class BankAccount
NumberOfTran Specialized
sactions; members int main()
{
SavingAccount s1,s2;
}
 Example : Banking
void debit(float amount)
Add following {
cout<<"base class method call debit(float
methods to amount)"<<endl;
accBalance=accBalance-amount;
BankAccount class cout<<"Amount Rs"<<amount<<" debited from your
acoount. current balance= Rs"<<accBalance<<endl;
void printaccountdetails(){ }
cout<<" Account void credit(float amount)
{
Num:"<<accno<<" cout<<"base class method credit(float
Balance="<<accBalance<<" amount)"<<endl;
name:"<<name<<endl<<" Mobile accBalance=accBalance+amount;
num 1:"<<mobile[0]<< cout<<"Amount Rs"<<amount<<" credited to your
account. current balance= Rs"<<accBalance;
"Mobile num
}
2"<<mobile[1]<<endl;
}
 Example : Banking
Object of SavingAccount
Add following methods to a1
Derived class accno
bool verifyMinimumBalance() accBalance
{ return accBalance<minimumBalance? name
true:false; mobile[]
} Inherited
printaccountdetails() members
Main function
debit(float amount)
int main()
{ credit(float amount)
SavingAccount a1,a2;
NumberOfTransactions;
a1.accBalance=500; Specialized
verifyMinimumBalance() members
a2.accBalance=1000;
int amount= 100;
 Example : Banking
Continued program from previous slide
if( a1.verifyMinimumBalance() ) What is the output?
{
cout<<"a1 has minimum
balance"<<endl;
if(a1.accBalance-amount>0)
{ a1.debit(amount);
cout<<"amount
"<<amount<<"debited from a1.
balance="<<a1.accBalance<<""<<endl;
}
}
cout<<"crediting to a2 account"<<endl;
a2.credit(amount);
cout<<" balance after credit
operation="<<a2.accBalance<<endl;
}
Generalization in UML Class Diagrams
 Constructors and inheritance
• Constructors are used to initialize the
members of object.
• A constructor can be added to Derived class
and Its good practice to reuse the constructor
defined in Base class. i.e derived class
constructor can call base class constructor.
 Constructors and inheritance
User defined
Default constructor
Add following constructors to base class Add following constructors to Derived
BankAccount():accno(0),accBalance(0),name("") class
{ Calling base class SavingAccount(): BankAccount()
Parameterized
mobile[0]=0; default {
constructor
mobile[1]=0; constructor while cout<<"Derived class constructor
cout<<"base class constructor BankAccount()
Redefining Default SavingAccount() invoked"<<endl;
invoked"<<endl;
constructor for
}
derived class }
BankAccount(int n,float m,string n1):
accno(n),accBalance(m),name(n1)
{
Derived class SavingAccount(int n,float m,string n1):
mobile[0]=12345678; Parameterized BankAccount(n, m, n1)
mobile[1]=23456789; constructor calling {
base
cout<<"base class constructor (intclass’s
n,float m,string cout<<"Derived class constructor
n1) invoked"<<endl; parameterized SavingAccount(int n,float m,string n1)
} invoked"<<endl;}
constructor
 Constructors and inheritance
Predict the output

SavingAccount s1;

SavingAccount s2(2,100000.0f,"ramesh");

• By default the derived class invokes the base class constructor.

• If base class doesn’t have default constructor and derived class doesn’t make
explicit call to base class constructor, then compiler error will be generated.
 Constructors and inheritance
• A class can inherit from multiple classes at the
same level of inheritance hierarchy.
 Example : Banking- Overriding
• Many times derived class may want to
redefine the behavior attained from base
class. Reason may be
– To enhance the definition of the behavior, or
– To exhibit the same behavior in a different way
 Example : Banking- Overriding
class BankAccount{
public: void credit(float amount)
int accno; {
float accBalance; cout<<"base class method credit(float amount)"<<endl;
string name; accBalance=accBalance+amount;
cout<<"Amount Rs"<<amount<<" credited to your
long mobile[2];
account. current balance= Rs"<<accBalance;
void printaccountdetails(){ }
cout<<" Account Num:"<<accno<<"
Balance="<<accBalance<<" name:"<<name<<endl<<" };// end of class BankAccount
Mobile num 1:"<<mobile[0]<<
"Mobile num 2"<<mobile[1]<<endl;
}
void debit(float amount)
{
cout<<"base class method call debit(float
amount)"<<endl;
accBalance=accBalance-amount;
cout<<"Amount Rs"<<amount<<" debited from your
acoount. current balance= Rs"<<accBalance<<endl;
}
 Example : Banking- Overriding
class SavingAccount: public BankAccount void credit(float amount)
{ {
public: cout<<"Derived class method call credit(float
amount)"<<endl;
int NumberOfTransactions;
NumberOfTransactions++;
static int minimumBalance, transactionsLimit; if(verifyMinimumBalance())
bool verifyMinimumBalance() {
{ return accBalance<minimumBalance? true:false; Overriding base cout<<"Warning: Minimum balance of Rs
} "<<minimumBalance<<"should be maintained"<<endl;
void debit(float amount)
class function
}
{ cout<<"Derived class method call debit(float amount)"<<endl;
if(amount>0)
NumberOfTransactions++; {
if(verifyMinimumBalance()) Calling base class BankAccount::credit(amount);
{ cout<<"Warning: Minimum balance of Rs
"<<minimumBalance<<"should be maintained"<<endl;
function }
else
} {
if(amount>accBalance) cout<<"credit transaction aborted due invalid credit
amount "<<endl;
{ cout<<"debit transaction aborted due to low balance"<<endl;
} }
else }
{ BankAccount::debit(amount); };// end of class SavingAccount
} int SavingAccount:: minimumBalance=500;
} int SavingAccount:: transactionsLimit=0;
 Example : Banking- Overriding
Class Diagrams Notation for SavingAccount
BankAccount inheritance
+NumberOfTransactions: int
+accno: int Static
+minimumBalance: int
+accBalance: float members are
+transactionsLimit: int
+name: string
Underlined
+SavingAccount()
+mobile: long[ ]
Base Class Sub Class
+SavingAccount(n: int, m: float, n1:string)
+BankAccount()
+verifyMinimumBalance(): void
+BankAccount( n:int, m: float, n1:string)
+debit(amount: float ): void
+printaccountdetails(): void
+credit(amount: float ): void
+debit(amount: float ): void
+credit(float amount): void
int main()
{ Example : Banking- Overriding
SavingAccount
s1(1,400.0f,"suresh"),s2(2,100000.0f,"ramesh");

cout<<"--suresh account details:"<<endl;

s1.printaccountdetails();
cout<<"--ramesh account details:"<<endl;
s2.printaccountdetails();

cout<<endl<<"### ramesh transactions"<<endl;

s2.debit(10000);
s2.credit(5000);

cout<<endl<<"### suresh transactions"<<endl;

s1.debit(100);
s1.credit(5000);
}
Access Specifier
 Access Specifier- Example : Banking
Class Diagrams SavingAccount
BankAccount
+NumberOfTransactions: int
+accno: int
+minimumBalance: int
-accBalance: float
+transactionsLimit: int
+name: string
+SavingAccount()
#mobile: long[ ]
+SavingAccount(n: int, m: float, n1:string)
+BankAccount()
-verifyMinimumBalance(): void
+BankAccount( n:int, m: float, n1:string)
+debit(amount: float ): void
+printaccountdetails(): void
+credit(amount: float ): void
#debit(amount: float ): void
#credit(float amount): void
 Access //Inside
Specifiersubclass
Predict the correct statements
void testAccessModifiers()
//Inside main function {
//or out side the class cout<<accno;
SavingAccount s1; cout<<accBalance;
cout<<s1.accno; cout<<mobile[0];
cout<<s1.accBalance; credit(100);
cout<<s1.mobile[0]; debit(100);
s1.credit(100); verifyMinimumBalance();
s1.debit(100); BankAccount::credit(100);
s1.verifyMinimumBalance(); BankAccount::debit(100);
}
class Box
{ Access Specifier
public: int main()
int length, width, height; {
}; ColorBox cb1;
class ColorBox: private Box cb1.length=10;
cb1.display();
{
}
public:
string color;
If Base class is inherited as private,
void display()
then Derived class cannot access
{ cout<<"L="<<length; the inherited public members
} outside the class
};
 Multiple Inheritance
• C++ allows a class to inherit from multiple classes
• It can be used in situation when a class is similar to
existing multiple classes.
• Multiple inheritance is not recommended due to
ambiguity it creates. Alternatively multiple class can be
inherited at multiple level.
• Ambiguities can be addressed by using class scope
resolution operator BaseClassName ::
 Multiple Inheritance
class Teacherclass PostGraduate
{public: string name;string name;
{public: class MtechTrainee: public Teacher, public PostGraduate
int teachingHours=0;
int attendence=0;
Teacher(string {public:int hours=0):name(nameT),teachingHours(hours)
nameT="n/a",
PostGraduate(string nameP="-name-", int att=0):name(nameP),
{ } attendence(att)MtechTrainee(string nameT="n/a", int hours=0, string
void teachLesson()
{} nameP="-name-", int att=0)
{ teachingHours++; } :Teacher(nameT,hours), PostGraduate(nameP,att)
void attendlecture()
void display()
{ { }
attendence++;
{ cout<<"Teacher
} name="<<name<<",
void show() Number of class
hours="<<teachingHours<<endl;
void display(){ }
Teacher::display();
}; { cout<<"post graduate name="<<name<<", attendence="<<
PostGraduate::display();
attendence<<endl; }
};
}
};
int main() Multiple Inheritance name= “rakesh”
rakesh
Inherited
{ from
teachingHours= 10
MtechTrainee vishal; Teacher
Teacher(string, int) class
cout<<"## Vishal details through \"vishal.show()\" "<<endl;
teachLesson()
vishal.show();
display()
name= “rocky”
MtechTrainee rakesh("rakesh",10,"rocky",2); Inherited
cout<<endl<<"## Rakesh details through inherited methods "<<endl; from
attendence= 2 PostGradu
cout<<"## function call- \"rakesh.Teacher::display()\" "<<endl;
PostGraduate(string, int ) ate
rakesh.Teacher::display(); class
attendlecture()
cout<<"## function call- \"rakesh.PostGraduate::display()\" "<<endl;
rakesh.PostGraduate::display(); display()
} MtechTrainee(string, int, string, int) Specialized
show() members
int main()
Multiple Inheritance
{
MtechTrainee vishal;
cout<<"## Vishal details through \"vishal.show()\" "<<endl;
vishal.show();

MtechTrainee rakesh("rakesh",10,"rocky",2);
cout<<endl<<"## Rakesh details through inherited methods "<<endl;
cout<<"## function call- \"rakesh.Teacher::display()\" "<<endl;
rakesh.Teacher::display();
cout<<"## function call- \"rakesh.PostGraduate::display()\" "<<endl;
rakesh.PostGraduate::display();
}
 Multiple Inheritance
If Multiple base classes inherit from same class, then resolving inherited function
call can be difficult.
Thank You