Virtual Function & Abstract

Classes
 Virtual Functions
 A means to achieve dynamic polymorphism
 A virtual function can have a definition in base

class, called in case derived class does not

override that function
 Used to support polymorphism with pointers and

references
 When virtual function called via pointer ->, the

reference is resolved at run time

 called dynamic binding
 When virtual function called by referencing a
specific object (using dot operator) reference
is resolved at compile time
 called static binding
 A virtual function declaration contains virtual
keyword
 A class that declares or inherits a virtual function
is called a polymorphic class.
 Any no static member function except a
constructor can be virtual
 Virtual Functions
 Virtual functions can also be friends of other
classes
 Some compilers require the class destructor to

be virtual if a class contains any virtual functions

 Non-virtual function can call virtual function

 Virtual functions in the base class provide

common interface for all of its derived classes

class MyClass
{
public:
virtual void MyFunction()
{
cout << “virtual function”;
}
};
 Pure Virtual Functions
 Pure virtual function ensures that all derived
classes must override it
 A pure virtual function,Vf, can have (optional)

definition in base class, can only be called

using Base::Vf()
 Pure virtual function declaration end with = 0;

an indication that it is a pure virtual function

 A class becomes Abstract if it contains at

least one pure virtual function

 Example: Pure virtual Functions

class Shape
{
public:
// pure virtual function
virtual void Draw() = 0;
};
 Abstract Classes
 Classes from which it is never intended to
instantiate any objects
 Incomplete—derived classes must define the
“missing pieces”.
 Too generic to define real objects.

 Normally used as base classes and called

abstract base classes
 Provide appropriate base class frameworks from
which other classes can inherit.
 Abstract Classes
 A class is made abstract by declaring one or more
of its virtual functions to be “pure”
 I.e., by placing "= 0" in its declaration
 A pure virtual function is a virtual member function
of a base class that must be overridden.
 Example

virtual void draw() const = 0;

 "= 0" is known as a pure specifier.

 Tells compiler that there is no implementation.

 Abstract classes can have data and concrete functions

 Required to have one or more pure virtual functions

 Concrete Classes

Classes used to instantiate objects

Provide specifics to make real objects
 Every concrete derived class must override all
base-class pure virtual functions
 with concrete implementations

If even one pure virtual function is not overridden,

the derived-class will also be abstract
 Abstract
AbstractClass
Class

Concrete
ConcreteClasses
Classes

11
class Shape
{
public:
virtual void Draw() = 0; // pure virtual function
};

class Line : public Shape

{
public:
//override interface function
void Draw() // also virtual in derived class
{
cout << “Line is being drawn”;
// …
}
};
 Example: Pure virtual Functions / Abstract Class (contd.)

void main()
{
// Shape obj; // error as Shape class is abstract
Line lineObj; // creating a derived class object
Shape* ptr; // creating a base class pointer

ptr = &linedObj; // assigning address of derived

class // object to base class pointer
ptr->Draw(); // derived class draw() will be
called
}