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	Pure Virtual Function
Virtual activity is the activity of a foundation phase member that can be redefined in acquired classes.	Pure virtual work is the work of a basic class member whose proclamation is in the foundation phase and implementation is in the acquired phase.
Virtual function-containing classes are not abstract classes.	The abstract classes are those that include only pure virtual functions.
In the case of a virtual function, the base class provides the function definition.	The definition of a function is not supplied in the base class for a pure virtual function.
It is possible to instantiate the base class that has a virtual function.	When a base class has only pure virtual functions, it becomes an abstract class that cannot be instantiated.
It will not affect the merger if the acquired category does not redefine the visible function of the foundation phase.	The derived class will not produce an error if it does not define the pure virtual function, but it will become an abstract class.
The virtual function may or may not be redefined by all descendant classes.	The pure virtual function must be defined by all derived classes.

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.