Abstract Class in C++

Must have feature of Abstract Classes

• We can only declare an abstract class, but can instantiate it.
• However, creation of pointed references is allowed, to support Runtime polymorphism
• Derived class generally use abstract classes to create interfaces
• They are used for upcasting
• If we use Pure Virtual functions to implement derived class then, we must implement all those functions in the derived classes without fail.
• Else by inheritance they will be abstract classes too.

Pure Virtual Functions

You must already know what Virtual functions are, they are used to support Runtime polymorphism and avoid early binding caused by static resolution at compile time.

• Any function in the base class which is preceded with keyword virtual are essentially Virtual functions.
• Pure Virtual functions are extension to Virtual functions and help us implement the concept of abstract classes properly.

The following is condition for a function to be a virtual function –

• should end with = 0;

For a virtual function be to pure virtual function it must have virtual keyword as

virtual void start() = 0

Let’s have a look at the whole program and understand the same.

class Vehicle
{
public:
virtual void features() = 0;
};

Example of a virtual function would be –

#include<iostream>
using namespace std;
class Parent
{
   public:
   virtual void print() = 0;
};
class Child : public Parent
{
   public:
   void print()
   {
     cout<<"Printing from Child(derived) class\n";
   }
};
int main()
{
   // we will try to implement this with both
   //pointer references and normal child class objects
   Child child1;
   Parent *parent;
   Child child2;
   parent = &child2;
   child1.print();
   parent->print();
   return 0;
}

Output –

Printing from Child(derived) class
Printing from Child(derived) class

The output in both cases is the same.

• In the first one since, object is of child class its obvious that child class
• In the second one runtime polymorphism is caused and it overrides the problem of static resolution at compile time early binding.