C++ - Pure Virtual Functions and Abstract Classes

Pure Virtual Functions and Abstract Classes

A pure virtual function is a virtual function in C++ for which we need not write any function definition and only have to declare it, where it is declared by assigning 0 in the declaration. To declare a virtual function, use the "virtual" keyword. 

Whereas, an abstract class is a class in C++ which have at least one pure virtual function.

Syntax

virtual return_type func_name(parameters) = 0;

Where

• return_type is the return type of the function (e.g., int, void, etc.)
• func_name is the name of the function.
• parameters is the list of parameters the function.
• = 0 syntax indicates that the function is pure virtual, which has no definition in the base class.

Example of Pure Virtual Function

class Shape {public:  // Pure virtual function
virtual void draw() = 0; };

Example of Abstract Class

An abstract class is a class that contains at least one pure virtual function.

class Shape {public: virtual void draw() = 0; // Pure virtual function makes Shape an abstract class
virtual ~Shape() {} // Virtual destructor (good practice)
};

Example of Pure Virtual Functions and Abstract Classes

Here is the full example showcasing the working of it.

#include<iostream>
using namespace std;

// Abstract class
class Shape {
  public: virtual void draw() = 0; // Pure virtual function
  virtual~Shape() {} // Virtual destructor
};

// Derived class: Circle
class Circle: public Shape {
  public: void draw() override {
    cout << "Drawing Circle" << endl;
  }
};

// Derived class: Rectangle
class Rectangle: public Shape {
  public: void draw() override {
    cout << "Drawing Rectangle" << endl;
  }
};

// Derived class: Triangle
class Triangle: public Shape {
  public: void draw() override {
    cout << "Drawing Triangle" << endl;
  }
};

int main() {
  Shape * shapes[] = {
    new Circle(),
    new Rectangle(),
    new Triangle()
  };

  // Draw all shapes
  for (Shape * shape: shapes) {
    shape -> draw();
  }

  // Cleanup
  for (Shape * shape: shapes) {
    delete shape;
  }

  return 0;
}

When the above code is compiled and executed, it produces the following result −

Drawing Circle
Drawing Rectangle
Drawing Triangle

Key Features of Abstract Classes

• Abstract classes can have normal functions and variables too, along with a pure virtual function.
• Abstract class cannot be instantiated, but pointers and references of Abstract class type can be created.
• Abstract classes are mainly used for Upcasting so that their derived classes can use its interface.
• If an Abstract Class has a derived class, it must implement all pure virtual functions, or else they will become Abstract too.
  
• We cant create an object of abstract class as we reserve a slot for a pure virtual function in Vtable, but we dont put any address, so Vtable will remain incomplete.