Virtual function

Virtual function

• A virtual function is a member function in a base class that can be overridden by a derived class to provide a different implementation. It allows the derived class to define its own version of the function, providing flexibility and extensibility in the object-oriented hierarchy.
• The virtual keyword is used to declare a function as virtual in the base class.
• Virtual functions enable dynamic polymorphism, which means that a function call is resolved dynamically at runtime based on the actual object type rather than the declared type. This allows objects of different derived classes to be treated uniformly through a base class pointer or reference, simplifying code and improving flexibility.
• When a virtual function is called through a base class pointer or reference, the function that is invoked is determined at runtime based on the type of the actual object being pointed to or referenced. This is known as dynamic or late binding.
• Virtual functions are typically used in scenarios where different derived classes need to provide their own implementation of a specific behavior defined in the base class. The base class provides a common interface through virtual functions, while the derived classes override these functions to customize their behavior.
• It is important to note that virtual functions should be declared in the base class and overridden in the derived classes using the override keyword to ensure proper overriding and to indicate the intention of overriding the base class function.

Let's resolve the problem

                   
#include <iostream>
using namespace std;
class base_class
{
public:
    virtual void show()
    {
        cout << "we are in base class yeah";
    }
};

class derived_class : public base_class
{
public:
    void show()
    {
        cout << "we are in derived class yeah";
    }
};

int main()
{
    base_class *basePtr;
    derived_class objOfDerivedC;
    basePtr = &objOfDerivedC;
    basePtr->show();
    return 0;
}
                   
               

Output ↓

                
we are in derived class yeah
                
            

• Just including 'virtual' in definition of show() function of base class, the problem is resolved.

Early binding & late binding

                   
#include <iostream>
using namespace std;

class Shape
{
public:
    void draw()
    {
        cout << "Drawing Shape." << endl;
    }
};

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

int main()
{
    Shape shape;
    Circle circle;

    Shape *shapePtr = &shape;
    shapePtr->draw(); // Calls Shape's draw() function (early binding)

    shapePtr = &circle;
    shapePtr->draw(); // Calls Shape's draw() function (early binding)

    return 0;
}
                   
               

                       
#include <iostream>
using namespace std;
class Shape
{
public:
    virtual void draw()
    {
        cout << "Drawing Shape." << endl;
    }
};

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

int main()
{
    Shape *shapePtr;
    Shape shape;
    Circle circle;

    shapePtr = &shape;
    shapePtr->draw(); // Calls Shape's draw() function (late binding)

    shapePtr = &circle;
    shapePtr->draw(); // Calls Circle's draw() function (late binding)

    return 0;
}
                       
                   

Pure virtual functions

• It is virtual function but there is no body.
• A pure virtual function is a virtual function declared in a base class that has no implementation.
• It is declared using the syntax ↓

                          
  virtual returnType functionName() = 0;
                          
                      

• A class containing a pure virtual function becomes an abstract class and cannot be instantiated.
• Derived classes must override pure virtual functions to provide their own implementation.

Example ↓

                   
#include <iostream>
using namespace std;
class Shape
{
public:
    virtual void draw() = 0; // Pure virtual function
};

class Circle : public Shape
{
public:
    void draw() override // overide is keyword which ensure we are overriding function in derived class from base class.
    {
        cout << "Drawing Circle." << endl;
    }
};

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

int main()
{
    Circle circle;
    Rectangle rectangle;

    circle.draw();    // Calls Circle's draw() function
    rectangle.draw(); // Calls Rectangle's draw() function

    return 0;
}
                   
               

Abstract classes

• An abstract class is a class that contains at least one pure virtual function.
• Abstract classes cannot be instantiated directly; they serve as base classes for derived classes.
• Derived classes must provide implementations for all pure virtual functions in the abstract base class.

Example program ↓

                   
#include <iostream>
using namespace std;
class Shape // abstract class
{
public:
    virtual void draw() = 0; // Pure virtual function
};

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

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

int main()
{
    Circle circle;
    Rectangle rectangle;

    circle.draw();
    rectangle.draw();

    return 0;
}
                   
               

How Runtime polymorphism and Compile-time polymorphism is related to early and late binding??

• So, late binding is associated with runtime polymorphism, where the appropriate function implementation is determined at runtime based on the actual object type. Early binding is associated with compile-time polymorphism, where the function call is resolved at compile time based on the static types of the objects involved.