What is abstract base class? Explain virtual function and polymorphism with example.

 An abstract base class is a class that cannot be instantiated on its own, but can be inherited by other classes to provide a common interface for a group of related classes. It defines a set of methods that must be implemented by any class that inherits from it, but does not provide an implementation for those methods itself.

A virtual function is a member function of a base class that is declared with the "virtual" keyword. When a derived class overrides the virtual function, it provides its own implementation of the function that is called instead of the base class implementation. This allows for polymorphism, which is the ability to treat objects of different derived classes as if they are objects of the same base class.

Here's an example program that demonstrates virtual functions and polymorphism:

#include <iostream>

using namespace std;
class Shape {
public:
    virtual void draw() = 0;
};
class Circle : public Shape {
public:
    void draw() {
        cout << "Drawing a circle" << endl;
    }
};
class Square : public Shape {
public:
    void draw() {
        cout << "Drawing a square" << endl;
    }
};
int main() {
    Shape *s1 = new Circle();
    Shape *s2 = new Square();
    
    s1->draw();  // Output: Drawing a circle
    s2->draw();  // Output: Drawing a square
    
    delete s1;
    delete s2;
    
    return 0;
}

In this program, we define an abstract base class Shape with a pure virtual function draw(). We then define two derived classes Circle and Square that inherit from Shape and implement their own version of the draw() function.

In the main function, we create two pointers of type Shape that point to objects of type Circle and Square. We then call the draw() function on each pointer, which outputs the message specific to each derived class.

Because the draw() function is virtual, the correct implementation of the function is called based on the actual type of the object being pointed to, rather than the type of the pointer. This demonstrates polymorphism, as we are treating objects of different derived classes as if they are objects of the same base class.