Object Oriented Programming using C++ - Part 3

OOPS THROUGH C++
1
Dr. Chandra Sekhar Sanaboina
Assistant Professor
Department of Computer Science and Engineering
University College of Engineering Kakinada
Jawaharlal Nehru Technological University Kakinada
Website: https://drcs.info
Youtube Link:
https://www.youtube.com/watch?v=nPjHraTbPeY&list=PLT1ngltOnlJiHbzVvjkU8VzQt9oam8ji4

UNIT – III
OPERATOR OVERLOADING AND TYPE CONVERSION
&
INHERITANCE
2

AGENDA
• Operator Overloading
• The keyword Operator
• Overloading Unary Operator
• Operator Return Type
• Overloading Assignment Operator (=)
• Rules for Overloading Operators
• Inheritance
• Reusability
• Types of Inheritance
• Virtual Base Classes
• Object as a Class Member
• Abstract Classes
• Advantages of Inheritance
• Disadvantages of Inheritance
3

OPERATOR OVERLOADING
• Introduction
• Operator overloading is an important concept in C++
• In C++, we can make operators to work for user defined classes
• This means C++ has the ability to provide the operators with a
special meaning for a data type, this ability is known as operator
overloading
• It is polymorphism in which an operator is overloaded to give user
defined meaning to it
• Overloaded operator is used to perform operation on user-defined
data type
• For example '+' operator can be overloaded to perform addition on
various data types, like for Integer, String(concatenation) etc.,
4

OPERATOR OVERLOADING CONTD…
• Important technique that has enhanced the power of
extendibility of C++
• C++ tries to make the user defined data types behave in
the same way as the built-in data types
• It is a type of polymorphism in which an operator is
overloaded to give the user defined meaning of it
5

DIFFERENCE BETWEEN OPERATOR
FUNCTIONS AND NORMAL FUNCTIONS?
• Operator functions are same as normal functions
• The only differences are
• name of an operator function is always operator keyword followed by
symbol of operator
• operator functions are called when the corresponding operator is used
6

• Almost any operator can be overloaded in C++
• However there are few operator which can not be overloaded
• Operator that are not overloaded are
• Scope Resolution Operator (::)
• sizeof
• Member Selector (.)
• Member Pointer Selector (*)
• Ternary Operator (?:)
7

Syntax for Operator Overloading
Returntype Classname :: operator OperatorSymbol (argumentlist)
{
Function Body
}
8

IMPLEMENTING OPERATOR OVERLOADING
• Operator overloading can be done by implementing a function
which can be :
• Member Function
• Non-Member Function
• Friend Function
• Operator overloading function can be a member function if the Left
operand is an Object of that class
• If the Left operand is different, then Operator overloading function
must be a non-member function
• Operator overloading function can be made friend function if it
needs access to the private and protected members of class
9

RESTRICTIONS ON OPERATOR OVERLOADING IN C++
• Following are some restrictions to be kept in mind while
implementing operator overloading
• Precedence and Associativity of an operator cannot be changed
• Arity (numbers of Operands) cannot be changed. Unary operator
remains unary, binary remains binary etc
• No new operators can be created, only existing operators can be
overloaded
• Cannot redefine the meaning of a procedure (i.e., we cannot
change how integers are added)
10

OVERLOADING ARITHMETIC OPERATORS IN C++
• Arithmetic operator are most commonly used operator in
C++
• Almost all arithmetic operator can be overloaded to
perform arithmetic operation on user-defined data type
11

OVERLOADING ARITHMETIC OPERATORS IN C++
#include <iostream>
#include <conio.h>
using namespace std;
class Time
{
int h,m,s;
public:
Time() { h=0, m=0; s=0; }
void setTime();
void show()
{
cout<<h<<":"<<m<<":"<<s;
}
//overloading '+' operator
Time operator +(Time);
};
void time::setTime()
{
cout << "n Enter the hour(0-11) ";
cin >> h;
cout << "n Enter the minute(0-59) ";
cin >> m;
cout << "n Enter the second(0-59) ";
cin >> s;
}
Time Time::operator+(Time t1) //operator function
{
Time t;
int a,b;
a = s+t1.s;
t.s = a%60;
b = (a/60)+m+t1.m;
t.m = b%60;
t.h = (b/60)+h+t1.h;
t.h = t.h%12;
return t;
}
void main() {
Time t1,t2,t3;
cout << "n Enter the first time ";
t1.setTime();
cout << "n Enter the second time ";
t2.setTime();
t3 = t1 + t2; //adding of two time object using '+' operator
//t3=t1.add(t2); - this is how the compiler treats the above
cout << "n First time ";
t1.show();
cout << "n Second time ";
t2.show();
cout << "n Sum of times ";
t3.show();
getch();
}
12

OVERLOADING RELATIONAL OPERATORS IN C++
• You can also overload relational operators like ==, !=, >=,
<= etc., to compare two object of any class
13

OVERLOADING RELATIONAL OPERATORS IN C++
class Time
{
int hr, min, sec;
public:
// default constructor
Time() { hr=0, min=0; sec=0; }
// overloaded constructor
Time(int h, int m, int s)
{ hr=h, min=m; sec=s; }
//overloading '==' operator
friend bool operator==(Time &t1, Time &t2);
};
bool operator== (Time &t1, Time &t2)
{
return ( t1.hr == t2.hr && t1.min == t2.min && t1.sec ==
t2.sec );
}
void main()
{
Time t1(3,15,45);
Time t2(4,15,45);
if(t1 == t2)
{
cout << "Both the time values are equal";
}
else
{
cout << "Both the time values are not equal";
}
}
14

FRIEND FUNCTIONS
• A friend function of a class is defined outside that class
scope
• Friend function has the right to access all private and
protected members of the class
• Even though the prototypes for friend functions appear in
the class definition, friends are not member functions
15

WHY FRIEND FUNCTION
• Special case when private members of the class need to
be accessed directly without using object of that class
• Used in Operator Overloading
16

FRIEND FUNCTION EXAMPLE
#include<iostream>
class Demo{
private:
int len;
public:
Demo()
{
len=0;
}
Demo(int l)
{
len=l;
}
friend void increase(Demo &d);
void print();
};
void Demo::print(){
cout<<"Length is "<<len<<endl;
}
void increase(Demo &d)
{
d.len=d.len+10;
}
int main(){
Demo d(5);
d.print();
increase(d);
d.print();}
17

OVERLOADING UNARY OPERATORS
• Unary operators operate on only one operand
• The increment operator ++ and decrement operator -- are
examples of unary operators
18

OVERLOADING UNARY OPERATOR
// Overload ++ when used as prefix
#include <iostream>
class Count {
private:
int value;
public:
// Constructor to initialize count to 5
Count() : value(5) {}
void operator ++ () {
++value;
}
void display() {
cout << "Count: " << value << endl;
}
};
int main() {
Count count1;
// Call the "void operator ++ ()" function
++count1;
count1.display();
return 0;
}
19

OVERLOADING UNARY OPERATORS
• For Postfix Operation:
void operator ++ (int)
{
value++;
}
20

OVERLOADING UNARY OPERATOR WITH RETURN VALUE
#include <iostream>
class Count {
private:
int value;
public
:
// Constructor to initialize count to 5
Count() : value(5) {}
Count operator ++ () {
Count temp;
// Here, value is the value attribute of the calling object
temp.value = ++value;
return temp;
}
/
//Overload ++ when used as postfix
Count operator ++ (int) {
Count temp;
// Here, value is the value attribute of the calling object
temp.value = value++;
return temp;
}
void display() {
cout << "Count: " << value << endl;
}
};
int main() {
Count count1, result;
// Call the "Count operator ++ ()" function
result = ++count1;
result.display();
// Call the "Count operator ++ (int)" function
result = count1++;
result.display();
return 0;
}
21

OVERLOADING ASSIGNMENT OPERATOR
• The assignment operator (operator=) is used to copy
values from one object to another already existing object
22

OVERLOADING ASSIGNMENT OPERATOR
#include <iostream>
class Distance {
private:
int feet; // 0 to infinite
int inches; // 0 to 12
public:
// required constructors
Distance() {
feet = 0;
inches = 0;
}
Distance(int f, int i) {
feet = f;
inches = i;
}
void operator = (const Distance &D ) {
feet = D.feet;
inches = D.inches;
}
// method to display distance
void displayDistance() {
cout << "F: " << feet << " I:" << inches << endl;
}
};
int main() {
Distance D1(11, 10), D2(5, 11);
cout << "First Distance : ";
D1.displayDistance();
cout << "Second Distance :";
// use assignment operator
D1 = D2;
cout << "First Distance :";
return 0;
}
23

RULES FOR OPERATOR OVERLOADING
• Only built-in operators can be overloaded. If some operators are
not present in C++, we cannot overload them.
• The arity of the operators cannot be changed
• The precedence of the operators remains same
• We cannot overload operators for built-in data types. At least one
user defined data types must be there.
• The assignment “=”, subscript “[]”, function call “()” and arrow
operator “->” these operators must be defined as member
functions, not the friend functions.
• Some operators like assignment “=”, address “&” and comma “,”
are by default overloaded. 24

INHERITANCE
• Introduction:
• The capability of a class to derive properties and characteristics from
another class is called Inheritance
• Inheritance is one of the most important feature of Object Oriented
Programming
• Sub Class: The class that inherits properties from another class is called
Sub class or Derived Class
• Super Class: The class whose properties are inherited by sub class is
called Base Class or Super class 26

WHY INHERITANCE?
• Reusability
• Consider a group of vehicles Bus, Car and Truck.
• We need to create classes for Bus, Car and Truck
• Assume the methods fuelAmount(), capacity(), applyBrakes() will be same for all of the
three classes
• If we create these classes avoiding inheritance then we have to write all of these
functions in each of the three classes
27

WHY INHERITANCE CONTD…
• You can clearly see that above process results in
duplication of same code 3 times
• Disadvantages:
• Increase in error rate and data redundancy
• To avoid this type of situation, inheritance is used
• If we create a class Vehicle and write these three
functions in it and inherit the rest of the classes from the
vehicle class, then we can simply avoid the duplication of
data and increase re-usability
28

IMPLEMENTING INHERITANCE IN C++
• For creating a sub-class which is inherited from the base
class we have to follow the below syntax:
class subclass_name : access_specifier base_class_name
{
//subclass body
};
• subclass_name is the name of the sub class
• access_mode is the mode in which you want to inherit this sub class
• base_class_name is the name of the base class from which you want to
inherit the sub class
29

INHERITANCE EXAMPLE
#include <bits/stdc++.h>
//Base class
class Parent
{
public:
int id_p;
};
// Sub class inheriting from Base Class(Parent)
class Child : public Parent
{
public:
int id_c;
};
//main function
int main()
{
Child obj1;
// An object of class child has all data members
// and member functions of class parent
obj1.id_c = 7;
obj1.id_p = 91;
cout << "Child id is " << obj1.id_c << endl;
cout << "Parent id is " << obj1.id_p << endl;
return 0;
}
30

MODES OF INHERITANCE
• Public mode:
• If we derive a sub class from a public base class
• Then the public member of the base class will become public in the derived class
and protected members of the base class will become protected in derived class
• Protected mode:
• If we derive a sub class from a Protected base class
• Then both public member and protected members of the base class will become
protected in derived class
• Private mode:
• If we derive a sub class from a Private base class
• Then both public member and protected members of the base class will become
Private in derived class
• Note: Private members of a base class cannot be directly accessed in
derived class, while protected members can be directly accessed
32

MODES OF INHERITANCE CONTD…
class A
{
public:
int x;
protected:
int y;
private:
int z;
};
class B : public A
{
// x is public
// y is protected
// z is not accessible from B
};
class C : protected A
{
// x is protected
// y is protected
// z is not accessible from C
};
class D : private A // 'private' is default for
classes
{
// x is private
// y is private
// z is not accessible from D
};
33

MODES OF INHERITANCE CONTD…
34

TYPES OF INHERITANCE
• Single Inheritance
• Multiple Inheritance
• Multilevel Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance
• Multipath Inheritance
36

SINGLE INHERITANCE
• Single Inheritance:
• In single inheritance, a class is allowed to inherit from only one class
• One sub class is inherited by one base class only
38

SINGLE INHERITANCE SYNTAX
class subclass_name : access_mode base_class1
{
//body of subclass
};
39

SINGLE INHERITANCE EXAMPLE
#include <iostream>
// base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" << endl;
}
};
// sub class derived from a single base classes
class Car: public Vehicle{
};
// main function
int main()
{
// creating object of sub class will
// invoke the constructor of base classes
Car obj;
return 0;
}
41

MULTIPLE INHERITANCE
• Multiple Inheritance:
• Multiple Inheritance is a feature of C++ where a class can inherit from
more than one classes
• i.e one sub class is inherited from more than one base classes
43

MULTIPLE INHERITANCE SYNTAX
class subclass_name : access_mode base_class1,
access_mode base_class2, ....
{
//body of subclass
};
45

MULTIPLE INHERITANCE EXAMPLE
#include <iostream>
// first base class
class Vehicle {
public:
Vehicle()
{
cout << "This is a Vehicle" <<
endl;
}
};
// second base class
class FourWheeler {
public:
FourWheeler()
{
cout << "This is a 4 wheeler
Vehicle" << endl;
}
};
// sub class derived from two base
classes
class Car: public Vehicle, public
FourWheeler {
};
// main function
int main()
{
// invoke the constructor of base
classes
Car obj;
return 0;
}
46

MULTILEVEL INHERITANCE
• Multilevel Inheritance:
• In this type of inheritance, a derived class is created from another
derived class
48

MULTILEVEL INHERITANCE EXAMPLE
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
}
};
// first sub_class derived from class vehicle
class fourWheeler: public Vehicle
{ public:
fourWheeler()
{
cout<<"Objects with 4 wheels are
vehicles"<<endl;
}
};
// sub class derived from the derived base
class fourWheeler
class Car: public fourWheeler{
public:
Car()
{
cout<<"Car has 4 Wheels"<<endl;
}
};
// main function
int main()
{
//creating object of sub class will
//invoke the constructor of base classes
Car obj;
return 0;
}
50

HIERARCHICAL INHERITANCE
• Hierarchical Inheritance:
• In this type of inheritance, more than one sub class is inherited from
a single base class
• i.e. more than one derived class is created from a single base class.
52

HIERARCHICAL INHERITANCE EXAMPLE
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle
{
};
// main function
int main()
{
// invoke the constructor of base
class
Car obj1;
Bus obj2;
return 0;
}
54

HYBRID INHERITANCE
• Hybrid (Virtual) Inheritance:
• Hybrid Inheritance is implemented by combining more than one
type of inheritance
• For example: Combining Hierarchical inheritance and Multiple
Inheritance
56

HYBRID INHERITANCE EXAMPLE
// C++ program for Hybrid Inheritance
#include <iostream>
// base class
class Vehicle
{
public:
Vehicle()
{
cout << "This is a Vehicle" <<
endl;
}
};
//base class
class Fare
{
public:
Fare()
{
cout<<"Fare of Vehiclen";
}
};
// first sub class
class Car: public Vehicle
{
};
// second sub class
class Bus: public Vehicle, public Fare
{
};
// main function
int main()
{
// invoke the constructor of base class
Bus obj2;
return 0;
}
58

MULTIPATH INHERITANCE
• Multipath Inheritance:
• A special case of hybrid inheritance
• A derived class with two base classes and these two base classes have
one common base class is called multipath inheritance
• An ambiguity can arise in this type of inheritance
• Example:
• Combining Hierarchical inheritance and Multiple Inheritance
60

MULTIPATH INHERITANCE EXAMPLE
// C++ program demonstrating ambiguity in
Multipath Inheritance
#include <conio.h>
#include <iostream.h>
class ClassA {
public:
int a;
};
class ClassB : public ClassA {
public:
int b;
};
class ClassC : public ClassA {
public:
int c;
};
class ClassD : public ClassB, public ClassC {
public:
int d;
};
void main()
{
ClassD obj;
// obj.a = 10;
//Statement 1, Error
// obj.a = 100;
//Statement 2, Error
obj.ClassB::a = 10; // Statement 3
obj.ClassC::a = 100; // Statement 4
obj.b = 20;
obj.c = 30;
obj.d = 40;
cout << "n A from ClassB : " <<
obj.ClassB::a;
cout << "n A from ClassC : " <<
obj.ClassC::a;
cout << "n B : " << obj.b;
cout << "n C : " << obj.c;
cout << "n D : " << obj.d;
}
61

AMBIGUITY
IN
MULTIPATH INHERITANCE
62

AMBIGUITY IN MULTIPATH INHERITANCE
• In the above example, both ClassB & ClassC inherit ClassA, they
both have single copy of ClassA
• However ClassD inherit both ClassB & ClassC, therefore ClassD
have two copies of ClassA, one from ClassB and another from
ClassC
• If we need to access the data member a of ClassA through the
object of ClassD, we must specify the path from which a will be
accessed, whether it is from ClassB or ClassC, bco’z compiler can’t
differentiate between two copies of ClassA in ClassD 63

HOW TO AVOID AMBIGUITY IN MULTIPATH INHERITANCE?
• There are 2 ways to avoid this ambiguity:
• Avoiding ambiguity using scope resolution operator:
• Using scope resolution operator we can manually specify the path from
which data member a will be accessed, as shown in statement 3 and 4, in
the above example.
• Example:
• obj.ClassB::a = 10; //Statement 3
• obj.ClassC::a = 100; //Statement 4
• Avoiding ambiguity using virtual base class:
• Explanation using a programming Example
64

SOLUTION 1 FOR RESOLVING AMBIGUITY –
USING SCOPE RESOLUTION OPERATOR
// C++ program demonstrating ambiguity in
Multipath Inheritance
#include <conio.h>
#include <iostream.h>
class ClassA {
public:
int a;
};
class ClassB : public ClassA {
public:
int b;
};
class ClassC : public ClassA {
public:
int c;
};
class ClassD : public ClassB, public ClassC {
public:
int d;
};
void main()
{
ClassD obj;
obj.ClassB::a = 10; // Statement 3
obj.ClassC::a = 100; // Statement 4
obj.b = 20;
obj.c = 30;
obj.d = 40;
cout << "n A from ClassB : " <<
obj.ClassB::a;
cout << "n A from ClassC : " <<
obj.ClassC::a;
cout << "n B : " << obj.b;
cout << "n C : " << obj.c;
cout << "n D : " << obj.d;
}
65

SOLUTION 2 FOR RESOLVING AMBIGUITY –
USING VIRTUAL BASE CLASSES
#include<iostream.h>
#include<conio.h>
class ClassA
{
public:
int a;
};
class ClassB : virtual public ClassA
{
public:
int b;
};
class ClassC : virtual public ClassA
{
public:
int c;
};
class ClassD : public ClassB, public ClassC
{
public:
int d;
};
void main()
{
ClassD obj;
obj.a = 10; //Statement 3
obj.a = 100; //Statement 4
obj.b = 20;
obj.c = 30;
obj.d = 40;
cout<< "n A : "<< obj.a;
cout<< "n B : "<< obj.b;
cout<< "n C : "<< obj.c;
cout<< "n D : "<< obj.d;
}
Note:
According to the above example, ClassD has only
one copy of ClassA, therefore, statement 4 will
overwrite the value of a, given at statement 3.
66

VIRTUAL BASE CLASSES
• Virtual base classes are used in virtual inheritance
• It is to prevent multiple “instances” of a given class appearing in an
inheritance hierarchy when using multiple inheritances
68

NEED FOR VIRTUAL BASE CLASSES
• Consider the situation where we have one class A
• This class is A is inherited by two other classes B and C
• Both these class are inherited into another in a new
class D as shown in figure
• The data members/function of class A are inherited twice
to class D - One through class B and second through
class C
• When any data / function member of class A is accessed
by an object of class D, ambiguity arises as to which
data/function member would be called? (One inherited
through B or the other inherited through C)
• This confuses compiler and it displays error
69

AMBIGUITY RAISED DUE TO INHERITANCE
#include <iostream>
class A {
public:
void show()
{
cout << "Hello form A n";
}
};
class B : public A {
};
class C : public A {
};
class D : public B, public C {
};
int main()
{
D object;
object.show();
}
Output: Error
70

HOW TO RESOLVE THE AMBIGUITY?
• Virtual base classes offer a way to save space and avoid ambiguities in class
hierarchies that use multiple inheritances
• When a base class is specified as a virtual base, it can act as an indirect base more
than once without duplication of its data members
• A single copy of its data members is shared by all the base classes that use virtual
base
• To resolve this ambiguity when class A is inherited in both class B and class C, it is
declared as virtual base class by placing a keyword virtual
• Syntax 1:
class B : virtual public A
{
};
• Syntax 2:
class C : virtual public A
{
};
• Now only one copy of data/function member will be copied to class C and
class B and class A becomes the virtual base class
• Note: virtual can be placed before or after public keyword
71

SOLUTION FOR AMBIGUITY – VIRTUAL BASE CLASSES
##include <iostream>
class A {
public:
int a;
A() // constructor
{
a = 10;
}
};
class B : public virtual A {
};
class C : public virtual A {
};
class D : public B, public C {
};
int main()
{
D object; // object creation of
class d
cout << "a = " << object.a <<
endl;
return 0;
}
72

ABSTRACT CLASSES
• Abstract Class is a class which contains atleast one Pure Virtual
function in it
• Abstract classes are used to provide an Interface for its sub classes
• Classes inheriting an Abstract Class must provide definition to the
pure virtual function, otherwise they will also become abstract class
74

CHARACTERISTICS OF ABSTRACT CLASS
• Abstract class cannot be instantiated, but pointers and references
of Abstract class type can be created
• Abstract class can have normal functions and variables along with
a pure virtual function
• Abstract classes are mainly used for Upcasting, so that its derived
classes can use its interface
• Classes inheriting an Abstract Class must implement all pure
virtual functions, or else they will become Abstract too
75

UPCASTING IN C++
• Upcasting is using the Super class's reference or pointer to
refer to a Sub class's object
or
• The act of converting a Sub class's reference or pointer into
its Super class's reference or pointer is called Upcasting
77

UPCASTING EXAMPLE
class Super
{
int x;
public:
void funBase()
{
cout << "Super function";
}
};
class Sub:public Super
{
int y;
};
int main()
{
Super* ptr; // Super class
pointer
Sub obj;
ptr = &obj;
Super &ref; // Super class's
reference
ref=obj;
}
78

VIRTUAL FUNCTIONS IN C++
• A virtual function is a member function in the base class that are expected to
redefine in derived classes
• Functions are declared with a virtual keyword in base class
• Basically, a virtual function is used in the base class in order to ensure that
the function is overridden
• This especially applies to cases where a pointer of base class points to an object of a
derived class
• They are mainly used to achieve Runtime polymorphism
• The resolving of function call is done at Run-time
80

VIRTUAL FUNCTIONS CONTD…
• Rules for Virtual Functions
• Virtual functions cannot be static
• A virtual function can be a friend function of another class
• Virtual functions should be accessed using pointer or reference of base class type to
achieve run time polymorphism
• The prototype of virtual functions should be the same in the base as well as derived
class
• They are always defined in the base class and overridden in a derived class. It is not
mandatory for the derived class to override (or re-define the virtual function), in that
case, the base class version of the function is used
• A class may have virtual destructor but it cannot have a virtual constructor 81

PURE VIRTUAL FUNCTIONS IN C++
• Pure virtual Functions are virtual functions with no definition
• They start with virtual keyword and ends with = 0
• Syntax:
• virtual void f() = 0;
83

PURE VIRTUAL FUNCTIONS EXAMPLE
class Base
{
public:
virtual void show() = 0; // Pure Virtual
Function
};
class Derived:public Base
{
public:
void show()
{
cout << "Implementation of Virtual
Function in Derived classn";
}
};
int main()
{
Base obj; //Compile Time Error
Base *b;
Derived d;
b = &d;
b->show();
}
Note: In the above example Base class is
abstract, with pure virtual show() function, hence
we cannot create object of base class.
84

WHY CAN'T WE CREATE OBJECT OF AN
ABSTRACT CLASS?
• When we create a pure virtual function in Abstract class, we
reserve a slot for a function in the VTABLE but doesn't put any
address in that slot
• Hence the VTABLE will be incomplete
• As the VTABLE for Abstract class is incomplete, hence the
compiler will not let the creation of object for such class and will
display an errror message whenever you try to do so
85

PURE VIRTUAL DEFINITIONS
• Pure Virtual functions can be given a small definition in the Abstract class,
which you want all the derived classes to have
• Still you cannot create object of Abstract class
• Also, the Pure Virtual function must be defined outside the class definition
• If you will define it inside the class definition, complier will give an error
• Inline pure virtual definition is Illegal 87

PURE VIRTUAL DEFINITION EXAMPLE
// Abstract base class
class Base
{
public:
virtual void show() = 0; //Pure Virtual
Function
};
void Base :: show() //Pure Virtual definition
{
cout << "Pure Virtual definitionn";
}
class Derived:public Base
{
public:
void show()
{
cout << "Implementation of Virtual
Function in Derived classn";
}
};
int main()
{
Base *b;
Derived d;
b = &d;
b->show();
}
88

ADVANTAGES
AND
DISADVANTAGES
89

ADVANTAGES OF INHERITANCE
• Inheritance promotes reusability:
• When a class inherits or derives another class, it can access all the functionality of inherited class
• Reusability enhanced reliability:
• The base class code will be already tested and debugged
• As the existing code is reused, it leads to less development and maintenance costs
• Inheritance makes the sub classes follow a standard interface
• Inheritance helps to reduce code redundancy and supports code extensibility
• Inheritance facilitates creation of class libraries
90

DISADVANTAGES OF INHERITANCE
• Inherited functions work slower than normal function as there is
indirection
• Improper use of inheritance may lead to wrong solutions
• Often, data members in the base class are left unused which may
lead to memory wastage
• Inheritance increases the coupling between base class and derived
class. A change in base class will affect all the child classes.
91

FUNCTIONS THAT ARE NEVER INHERITED
• Constructors and Destructors are never inherited and hence
never overrided
• Assignment Operator (=) is never inherited (It can be
overloaded but can never be inherited)
92

Object Oriented Programming using C++ - Part 3

Recommended

More Related Content

What's hot (20)

Similar to Object Oriented Programming using C++ - Part 3 (20)

Recently uploaded (20)

Object Oriented Programming using C++ - Part 3