What are Pure Virtual Functions in C++? (with Example)

Let's break our main topic into bits.  Look at this equation: Pure Virtual Functions = Pure + Virtual + functions. Following from right, we know about functions, and "Virtual" means virtual keyword which we use to achieve late binding as we implement it in virtual functions. In this article, we will look actually what are pure virtual functions in C++ with examples and advantages.

What is a Pure Virtual Function in C++?

A pure virtual function in C++ is a function that is declared in the base class but you cannot implement it, with a '0' assigned to make them pure. In this way, the base class becomes an abstract class, and it must be inherited by a derived class, which provides an implementation for it. 

Basically, they have the following characteristics:

• These functions also must have a prefix before the function's name called 'virtual'.
• In the base class, you can declare it, but you cannot implement it.
• '0' must be assigned to the function to make them pure. 
• The derived class must provide the implementation code for this function, else this derived class is also termed an 'abstract class'.

Note that classes having at least one pure virtual function are called Abstract classes. Now we know theoretically, what are important points to keep in mind about the pure virtual functions to define, then let's just quickly have a look at its syntax as well. 

Given below is the way to declare the pure virtual functions in C++ :

virtual function_type function_name() = 0;

The main use of pure virtual functions is to create an abstract class that defines an interface for its derived classes. An abstract class is like a base class for other classes to provide a common interface to implement. This helps us use the polymorphism feature of the programming language.

Pure Virtual Function C++ Example

Since we already understand the declaration part of a pure virtual function, now let's see how to code it in C++ and how to provide its implementation in the derived class. Given below can be the best example :

//Welcome to FavTutor

#include<iostream>
using namespace std;  
// here is Abstract class  
class Shape  
{  
    public:  
    virtual int cal_Area() = 0; // cal_Area is a pure virtual function   
};  
class Square : public Shape  
{  
    int a;  
    public:  
    Square(int l)  
    {  
        a = l;  
    }  
    int cal_Area()  
    {  
        return a*a;    // returns area of square
    }  
};  
class Circle : public Shape  
{  
    int r;  
    public:  
      
    Circle(int x)  
    {  
        r = x;  
    }  
    int cal_Area()  
    {  
        return 3.14*r*r ;  
    }  
};  
class Rectangle : public Shape  
{  
    int l;  
    int b;  
    public:  
    Rectangle(int x, int y)  
    {  
       l=x;  
       b=y;  
    }  
    int cal_Area()  
    {  
        return l*b;  // returns the product of length and breadth
    }  
};  
int main()    // main function
{  
      
    Shape *shape;  
    Square s(3.4);  
    Rectangle r(5,6);  
    Circle c(7.8);  
    shape =&s;  
    int a1 =shape->cal_Area();  
    shape = &r;  
    int a2 = shape->cal_Area();  
    shape = &c;  
    int a3 = shape->cal_Area();  
    std::cout << "The area of square is: " <<a1<< std::endl;  
    std::cout << "The area of  rectangle is: " <<a2<< std::endl;  
    std::cout << "The area of  circle is: " <<a3<< std::endl;  
    return 0;  
}  

Output:

The area of square is: 11
The area of  rectangle is: 30
The area of  circle is: 191

After going through the above, you can observe that we define a shape class as a base, then we are deriving classes from it and using the member function of the base class to calculate the area, the important thing to note here is that we are efficiently using the pure virtual function cal_area.

But how? See we are not using multiple functions in every derived class to calculate the area rather we are using just the different implementations of it by defining it once in the base class, I hope this will put you in a state where you have found yourself more powerful as you have this craziest tool to use it in your C++ program now. 

Virtual Function vs Pure Virtual Function

The following are the differences between a virtual and a pure virtual function in C++. A virtual function and a pure virtual function are both declared with the word "virtual" at the beginning of the code declaration, but their syntax is different.

Syntax of virtual function:

virtual<function_type><function_name>()
{
    // code
}

Syntax of pure virtual function:

virtual<function_type><function_name>()
    = 0;

Look at the below table for a complete list of differences:

Advantages of Pure Virtual Functions

Let's now look at the key advantages of pure virtual functions in C++ one by one:

1. Abstraction: Pure virtual functions are a way to separate the interface from the implementation, to make the code easier to maintain.
2. Polymorphism: A base class pointer is used to call functions of its derived classes, a key way to use polymorphism in C++.
3. Reusability: Since we define a common interface, we reduce the amount of code and make it more reusable.

Overall, they are one way to use the object-oriented programming features of C++ and make the code more modular and maintainable.

Conclusion 

Hope this article clears your concepts of pure virtual functions in C++ and more specifically, why it is pure. Now you can also use it in your C++ program too instead of creating multiple different functions in every other derived class, define it only once in the base class and create your own implementations. Happy Learning :)