In the article Properties of Virtual Functions, we discussed about two properties of virtual functions in detail. In this article we’ll be discussing about some properties of Pure Virtual Functions.
Property #1: We know that a base class can’t define a pure virtual function and at the same time its derived class must define it. But what if the derived class is used as base for deriving yet another class; is this possible?
Yes, it is, as is obvious from the following program:
#include <iostream.h>
// base class
class base
{
public:
// pure virtual function
// declaration
virtual void func() = 0;
};
// derived class
class derived1 : public base
{
public:
// must define
void func()
{
cout<<"Derived1's func()\n";
}
};
// derived from class derived1
class derived2 : public derived1
{
public:
void func()
{
cout<<"Derived2's func()\n";
}
};
// main
void main()
{
derived1 d1;
derived2 d2;
d1.func();
d2.func();
}
Hence strictly speaking, a pure virtual function cannot be declared and defined in the same class.
Property #2: While it’s necessary for a derived class to override a pure virtual function but if we derive yet another class from that derived class then it’s not necessary for the newly derived class to override that function.
So that means, if we have a hierarchy of derived classes then a pure virtual function must be overridden at least once.
It is clear from the following program:
#include <iostream.h>
// base class
class base
{
public:
// pure virtual function
// declaration
virtual void func() = 0;
};
// derived class
class derived1 : public base
{
public:
// must define
void func()
{
cout<<"Derived1's func()\n";
}
};
// derived from class derived1
class derived2 : public derived1
{
public:
// may not override the
// pure virtual function
};
// main
void main()
{
derived1 d1;
derived2 d2;
d1.func();
// derived1's function will
// be called
d2.func();
}
Property #3: We know that we can’t declare objects of Abstract Classes but since C++ offers very powerful Polymorphism capability, we can have their pointer (as well as references).
It is clear from the following program:
#include <iostream.h>
// base class
class base
{
public:
// pure virtual function
// declaration
virtual void func() = 0;
};
// derived class
class derived1 : public base
{
public:
// must define
void func()
{
cout<<"Derived1's func()\n";
}
};
// derived from class derived1
class derived2 : public derived1
{
public:
void func()
{
cout<<"Derived2's func()\n";
}
};
// main
void main()
{
// although objects of abstract classes
// cannot be declared but we can have
// their pointers
base *bptr;
derived1 d1;
derived2 d2;
// point to derived1 's object
bptr=&d1;
// derived1's func will be called
bptr->func();
// point to derived2's object
bptr=&d2;
// derived2's func will be called
// same interface is used
// but different function
// is called
bptr->func();
}
Related Articles: