Virtual Function Vs Pure Virtual Function

Virtual activity is a member function defined in the foundation phase that can be redefined by acquired classes.

Let's have a look at an example:

#include <iostream>  
#include <bits/stdc++.h>
#include <stdlib>
using namespace std;  
class Base  
{  
    public:  
    void show()  
    {  
        std::cout << "Base class" << std::endl;  
    }  
};  
class derived_1 : public Base  
{  
    public:  
    void show()  
    {  
        std::cout << "Derived class 1" << std::endl;  
    }  
};  
class derived_2 : public Base  
{  
    public:  
    void show()  
    {  
        std::cout << "Derived class 2" << std::endl;  
    }  
};  
int main()  
{  
    Base *be;  
    derived_1 de1;  
    derived_2 de2;  
    be=&de1;  
    be->show();  
    be=&de2;  
    be->show();  
    return 0;  
}

OUTPUT:

Derived Class 1
Derived Class 2

Explanation:

We haven't utilized the virtual method in the code above. The display () function is contained in a basic class that we developed. The two classes 'derived_1' and 'derived_2' are also formed and inherit the attributes of the base class. The display () function has been redefined in both the derived_1 and derived_2 classes. The pointer variable 'be' of class base is defined inside the main () function. de1 and de2 are the objects of the derived_1 and derived_2 classes, respectively. Although the 'be' contains the addresses of de1 and de2, when invoking the display () method, it always uses the base class's show () method rather than the derived_1 and derived_2 class's methods.

To solve the past problem, we have to make the path a reality in the Foundation class. The word "virtual" refers to a path that seems to exist but is not real. By simply preceding the function with the virtual keyword, we may make the method virtual. In the above application, we must add the virtual keyword before the display () function in the base class, as seen below:

virtual void show ()  
{  
    std::cout << "Base_Class" << std::endl;  //Base class
}   

Note:

• If the function is made virtual, the compiler will choose which function to execute at run time based on the location supplied to the base class's reference.
• It is a polymorphism that occurs during operation.
• If the foundation phase and the found phase both have the same function name and the foundation phase is given the address of the class acquired object, the base phase function will be used.

What is the definition of pure virtual function?

A pure virtual function is one that does not have a definition in the class. Let’s look at an example to better grasp the concept of pure visual performance. Shape is the basic class in the diagram above, whereas rectangle, square, and circle are the derived classes. Because we haven't given the virtual function any definition, it will be automatically changed to a pure virtual function.

Pure virtual function characteristics:

• Pure virtual function is an idle activity. "Do nothing" here refers to the fact that it just offers the template, while the derived class implements the function.
• It is possible to think of it as an empty function because the pure virtual function has no definition in relation to the base class.
• Because pure virtual activity has no definition in the foundation phase, programmers have to redefine it in the acquired category.
• A class with only virtual functions cannot be utilized to produce its own direct objects. It indicates that if the class has any pure virtual functions, we won't be able to build an object from it. An abstract class is the name for this sort of class.

A virtual function can be created in two ways:

Virtual void display () = NULL;//syntax1

Virtual void display () { }  //syntax2

Let's have a look at an example of pure virtual function:

#include <iostream>  
#include <bits/stdc++.h>
#include <stdlib>
using namespace std;  
// Creating Abstract class  
class Create_Shape  
{  
    public:  
    virtual float calculate_Area() = 0; // pure virtual function.  
};  
class Create_Square : public Create_Shape  
{  
    float i;  
    public:  
    Create_Square(float length)  
    {  
        i = length;  
    }  
    float calculate_Area()  
    {  
        return i*i;  
    }  
};  
class Create_Circle : public Create_Shape  
{  
    float radius;  
    public:  
      
    Circle(float x)  
    {  
        radius = x;  
    }  
    float calculate_Area()  
    {  
        return 3.14*radius*radius ;  
    }  
};  
class Create_Rectangle : public Create_Shape  
{  
    float length;  
    float breadth;  
    public:  
    Rectangle(float x, float y)  
    {  
       length=x;  
       breadth=y;  
    }  
    float calculate_Area()  
    {  
        return length*breadth;  
    }  
};  
int main()  
{  
      
    Create_Shape *shape;  
    Create_Square s(3.4);  
    Create_Rectangle radius(5,6);  
    Create_Circle c(7.8);  
    shape =&s;  
    int i1 =shape->calculate_Area();  
    shape = &radius;  
    int i2 = shape->calculate_Area();  
    shape = &c;  
    int i3 = shape->calculate_Area();  
    std::cout << "Area of the square is " <<i1<< std::endl;  
    std::cout << "Area of the rectangle is " <<i2<< std::endl;  
    std::cout << "Area of the circle is " <<i3<< std::endl;  
    return 0;  
}

OUTPUT:

Area of the square is 11.56
Area of rectangle is 30
Area of circle is 191.03
…………………………………………
Process executed in 1329 seconds
Press any key to continue.

What is the difference between a virtual function and a pure virtual function?

Virtual function and pure virtual function have certain similarities:

• Run-time polymorphism is made up of these principles.
• The prototype, that is, the declaration of both functions, stays the same throughout the program.
• These functions cannot be static or global.